gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21
  22 This paragraph is here to try to keep Sun CC from dying.
  23 The number of chars here seems crucial!!!!  */
  24
  25 /* This program is the user interface to the C compiler and possibly to
  26 other compilers.  It is used because compilation is a complicated procedure
  27 which involves running several programs and passing temporary files between
  28 them, forwarding the users switches to those programs selectively,
  29 and deleting the temporary files at the end.
  30
  31 CC recognizes how to compile each input file by suffixes in the file names.
  32 Once it knows which kind of compilation to perform, the procedure for
  33 compilation is specified by a string called a "spec".  */
  34
  35 /* A Short Introduction to Adding a Command-Line Option.
  36
  37    Before adding a command-line option, consider if it is really
  38    necessary.  Each additional command-line option adds complexity and
  39    is difficult to remove in subsequent versions.
  40
  41    In the following, consider adding the command-line argument
  42    `--bar'.
  43
  44    1. Each command-line option is specified in the specs file.  The
  45    notation is described below in the comment entitled "The Specs
  46    Language".  Read it.
  47
  48    2. In this file, add an entry to "option_map" equating the long
  49    `--' argument version and any shorter, single letter version.  Read
  50    the comments in the declaration of "struct option_map" for an
  51    explanation.  Do not omit the first `-'.
  52
  53    3. Look in the "specs" file to determine which program or option
  54    list should be given the argument, e.g., "cc1_options".  Add the
  55    appropriate syntax for the shorter option version to the
  56    corresponding "const char *" entry in this file.  Omit the first
  57    `-' from the option.  For example, use `-bar', rather than `--bar'.
  58
  59    4. If the argument takes an argument, e.g., `--baz argument1',
  60    modify either DEFAULT_SWITCH_TAKES_ARG or
  61    DEFAULT_WORD_SWITCH_TAKES_ARG in this file.  Omit the first `-'
  62    from `--baz'.
  63
  64    5. Document the option in this file's display_help().  If the
  65    option is passed to a subprogram, modify its corresponding
  66    function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
  67    instead.
  68
  69    6. Compile and test.  Make sure that your new specs file is being
  70    read.  For example, use a debugger to investigate the value of
  71    "specs_file" in main().  */
  72
  73 #include "config.h"
  74 #include "system.h"
  75 #include "coretypes.h"
  76 #include "multilib.h" /* before tm.h */
  77 #include "tm.h"
  78 #include <signal.h>
  79 #if ! defined( SIGCHLD ) && defined( SIGCLD )
  80 #  define SIGCHLD SIGCLD
  81 #endif
  82 #include "obstack.h"
  83 #include "intl.h"
  84 #include "prefix.h"
  85 #include "gcc.h"
  86 #include "flags.h"
  87
  88 #ifdef HAVE_SYS_RESOURCE_H
  89 #include <sys/resource.h>
  90 #endif
  91 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
  92 extern int getrusage (int, struct rusage *);
  93 #endif
  94
  95 /* By default there is no special suffix for target executables.  */
  96 /* FIXME: when autoconf is fixed, remove the host check - dj */
  97 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
  98 #define HAVE_TARGET_EXECUTABLE_SUFFIX
  99 #endif
 100
 101 /* By default there is no special suffix for host executables.  */
 102 #ifdef HOST_EXECUTABLE_SUFFIX
 103 #define HAVE_HOST_EXECUTABLE_SUFFIX
 104 #else
 105 #define HOST_EXECUTABLE_SUFFIX ""
 106 #endif
 107
 108 /* By default, the suffix for target object files is ".o".  */
 109 #ifdef TARGET_OBJECT_SUFFIX
 110 #define HAVE_TARGET_OBJECT_SUFFIX
 111 #else
 112 #define TARGET_OBJECT_SUFFIX ".o"
 113 #endif
 114
 115 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
 116
 117 /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
 118 #ifndef LIBRARY_PATH_ENV
 119 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
 120 #endif
 121
 122 #ifndef HAVE_KILL
 123 #define kill(p,s) raise(s)
 124 #endif
 125
 126 /* If a stage of compilation returns an exit status >= 1,
 127    compilation of that file ceases.  */
 128
 129 #define MIN_FATAL_STATUS 1
 130
 131 /* Flag set by cppspec.c to 1.  */
 132 int is_cpp_driver;
 133
 134 /* Flag saying to pass the greatest exit code returned by a sub-process
 135    to the calling program.  */
 136 static int pass_exit_codes;
 137
 138 /* Definition of string containing the arguments given to configure.  */
 139 #include "configargs.h"
 140
 141 /* Flag saying to print the directories gcc will search through looking for
 142    programs, libraries, etc.  */
 143
 144 static int print_search_dirs;
 145
 146 /* Flag saying to print the full filename of this file
 147    as found through our usual search mechanism.  */
 148
 149 static const char *print_file_name = NULL;
 150
 151 /* As print_file_name, but search for executable file.  */
 152
 153 static const char *print_prog_name = NULL;
 154
 155 /* Flag saying to print the relative path we'd use to
 156    find libgcc.a given the current compiler flags.  */
 157
 158 static int print_multi_directory;
 159
 160 /* Flag saying to print the relative path we'd use to
 161    find OS libraries given the current compiler flags.  */
 162
 163 static int print_multi_os_directory;
 164
 165 /* Flag saying to print the list of subdirectories and
 166    compiler flags used to select them in a standard form.  */
 167
 168 static int print_multi_lib;
 169
 170 /* Flag saying to print the command line options understood by gcc and its
 171    sub-processes.  */
 172
 173 static int print_help_list;
 174
 175 /* Flag indicating whether we should print the command and arguments */
 176
 177 static int verbose_flag;
 178
 179 /* Flag indicating whether we should ONLY print the command and
 180    arguments (like verbose_flag) without executing the command.
 181    Displayed arguments are quoted so that the generated command
 182    line is suitable for execution.  This is intended for use in
 183    shell scripts to capture the driver-generated command line.  */
 184 static int verbose_only_flag;
 185
 186 /* Flag indicating to print target specific command line options.  */
 187
 188 static int target_help_flag;
 189
 190 /* Flag indicating whether we should report subprocess execution times
 191    (if this is supported by the system - see pexecute.c).  */
 192
 193 static int report_times;
 194
 195 /* Nonzero means place this string before uses of /, so that include
 196    and library files can be found in an alternate location.  */
 197
 198 #ifdef TARGET_SYSTEM_ROOT
 199 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 200 #else
 201 static const char *target_system_root = 0;
 202 #endif
 203
 204 /* Nonzero means pass the updated target_system_root to the compiler.  */
 205
 206 static int target_system_root_changed;
 207
 208 /* Nonzero means append this string to target_system_root.  */
 209
 210 static const char *target_sysroot_suffix = 0;
 211
 212 /* Nonzero means append this string to target_system_root for headers.  */
 213
 214 static const char *target_sysroot_hdrs_suffix = 0;
 215
 216 /* Nonzero means write "temp" files in source directory
 217    and use the source file's name in them, and don't delete them.  */
 218
 219 static int save_temps_flag;
 220
 221 /* Nonzero means use pipes to communicate between subprocesses.
 222    Overridden by either of the above two flags.  */
 223
 224 static int use_pipes;
 225
 226 /* The compiler version.  */
 227
 228 static const char *compiler_version;
 229
 230 /* The target version specified with -V */
 231
 232 static const char *const spec_version = DEFAULT_TARGET_VERSION;
 233
 234 /* The target machine specified with -b.  */
 235
 236 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 237
 238 /* Nonzero if cross-compiling.
 239    When -b is used, the value comes from the `specs' file.  */
 240
 241 #ifdef CROSS_COMPILE
 242 static const char *cross_compile = "1";
 243 #else
 244 static const char *cross_compile = "0";
 245 #endif
 246
 247 #ifdef MODIFY_TARGET_NAME
 248
 249 /* Information on how to alter the target name based on a command-line
 250    switch.  The only case we support now is simply appending or deleting a
 251    string to or from the end of the first part of the configuration name.  */
 252
 253 static const struct modify_target
 254 {
 255   const char *const sw;
 256   const enum add_del {ADD, DELETE} add_del;
 257   const char *const str;
 258 }
 259 modify_target[] = MODIFY_TARGET_NAME;
 260 #endif
 261
 262 /* The number of errors that have occurred; the link phase will not be
 263    run if this is nonzero.  */
 264 static int error_count = 0;
 265
 266 /* Greatest exit code of sub-processes that has been encountered up to
 267    now.  */
 268 static int greatest_status = 1;
 269
 270 /* This is the obstack which we use to allocate many strings.  */
 271
 272 static struct obstack obstack;
 273
 274 /* This is the obstack to build an environment variable to pass to
 275    collect2 that describes all of the relevant switches of what to
 276    pass the compiler in building the list of pointers to constructors
 277    and destructors.  */
 278
 279 static struct obstack collect_obstack;
 280
 281 /* These structs are used to collect resource usage information for
 282    subprocesses.  */
 283 #ifdef HAVE_GETRUSAGE
 284 static struct rusage rus, prus;
 285 #endif
 286
 287 /* Forward declaration for prototypes.  */
 288 struct path_prefix;
 289
 290 static void init_spec (void);
 291 static void store_arg (const char *, int, int);
 292 static char *load_specs (const char *);
 293 static void read_specs (const char *, int);
 294 static void set_spec (const char *, const char *);
 295 static struct compiler *lookup_compiler (const char *, size_t, const char *);
 296 static char *build_search_list (struct path_prefix *, const char *, int);
 297 static void putenv_from_prefixes (struct path_prefix *, const char *);
 298 static int access_check (const char *, int);
 299 static char *find_a_file (struct path_prefix *, const char *, int, int);
 300 static void add_prefix (struct path_prefix *, const char *, const char *,
 301                         int, int, int *, int);
 302 static void add_sysrooted_prefix (struct path_prefix *, const char *,
 303                                   const char *, int, int, int *, int);
 304 static void translate_options (int *, const char *const **);
 305 static char *skip_whitespace (char *);
 306 static void delete_if_ordinary (const char *);
 307 static void delete_temp_files (void);
 308 static void delete_failure_queue (void);
 309 static void clear_failure_queue (void);
 310 static int check_live_switch (int, int);
 311 static const char *handle_braces (const char *);
 312 static inline bool input_suffix_matches (const char *, const char *);
 313 static inline bool switch_matches (const char *, const char *, int);
 314 static inline void mark_matching_switches (const char *, const char *, int);
 315 static inline void process_marked_switches (void);
 316 static const char *process_brace_body (const char *, const char *, const char *, int, int);
 317 static const struct spec_function *lookup_spec_function (const char *);
 318 static const char *eval_spec_function (const char *, const char *);
 319 static const char *handle_spec_function (const char *);
 320 static char *save_string (const char *, int);
 321 static void set_collect_gcc_options (void);
 322 static int do_spec_1 (const char *, int, const char *);
 323 static int do_spec_2 (const char *);
 324 static void do_option_spec (const char *, const char *);
 325 static void do_self_spec (const char *);
 326 static const char *find_file (const char *);
 327 static int is_directory (const char *, const char *, int);
 328 static const char *validate_switches (const char *);
 329 static void validate_all_switches (void);
 330 static inline void validate_switches_from_spec (const char *);
 331 static void give_switch (int, int);
 332 static int used_arg (const char *, int);
 333 static int default_arg (const char *, int);
 334 static void set_multilib_dir (void);
 335 static void print_multilib_info (void);
 336 static void perror_with_name (const char *);
 337 static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN;
 338 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
 339 static void display_help (void);
 340 static void add_preprocessor_option (const char *, int);
 341 static void add_assembler_option (const char *, int);
 342 static void add_linker_option (const char *, int);
 343 static void process_command (int, const char **);
 344 static int execute (void);
 345 static void alloc_args (void);
 346 static void clear_args (void);
 347 static void fatal_error (int);
 348 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
 349 static void init_gcc_specs (struct obstack *, const char *, const char *,
 350                             const char *);
 351 #endif
 352 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
 353 static const char *convert_filename (const char *, int, int);
 354 #endif
 355
 356 static const char *if_exists_spec_function (int, const char **);
 357 static const char *if_exists_else_spec_function (int, const char **);
 358 \f
 359 /* The Specs Language
 360
 361 Specs are strings containing lines, each of which (if not blank)
 362 is made up of a program name, and arguments separated by spaces.
 363 The program name must be exact and start from root, since no path
 364 is searched and it is unreliable to depend on the current working directory.
 365 Redirection of input or output is not supported; the subprograms must
 366 accept filenames saying what files to read and write.
 367
 368 In addition, the specs can contain %-sequences to substitute variable text
 369 or for conditional text.  Here is a table of all defined %-sequences.
 370 Note that spaces are not generated automatically around the results of
 371 expanding these sequences; therefore, you can concatenate them together
 372 or with constant text in a single argument.
 373
 374  %%     substitute one % into the program name or argument.
 375  %i     substitute the name of the input file being processed.
 376  %b     substitute the basename of the input file being processed.
 377         This is the substring up to (and not including) the last period
 378         and not including the directory.
 379  %B     same as %b, but include the file suffix (text after the last period).
 380  %gSUFFIX
 381         substitute a file name that has suffix SUFFIX and is chosen
 382         once per compilation, and mark the argument a la %d.  To reduce
 383         exposure to denial-of-service attacks, the file name is now
 384         chosen in a way that is hard to predict even when previously
 385         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
 386         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
 387         the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
 388         had been pre-processed.  Previously, %g was simply substituted
 389         with a file name chosen once per compilation, without regard
 390         to any appended suffix (which was therefore treated just like
 391         ordinary text), making such attacks more likely to succeed.
 392  %|SUFFIX
 393         like %g, but if -pipe is in effect, expands simply to "-".
 394  %mSUFFIX
 395         like %g, but if -pipe is in effect, expands to nothing.  (We have both
 396         %| and %m to accommodate differences between system assemblers; see
 397         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
 398  %uSUFFIX
 399         like %g, but generates a new temporary file name even if %uSUFFIX
 400         was already seen.
 401  %USUFFIX
 402         substitutes the last file name generated with %uSUFFIX, generating a
 403         new one if there is no such last file name.  In the absence of any
 404         %uSUFFIX, this is just like %gSUFFIX, except they don't share
 405         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
 406         would involve the generation of two distinct file names, one
 407         for each `%g.s' and another for each `%U.s'.  Previously, %U was
 408         simply substituted with a file name chosen for the previous %u,
 409         without regard to any appended suffix.
 410  %jSUFFIX
 411         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
 412         writable, and if save-temps is off; otherwise, substitute the name
 413         of a temporary file, just like %u.  This temporary file is not
 414         meant for communication between processes, but rather as a junk
 415         disposal mechanism.
 416  %.SUFFIX
 417         substitutes .SUFFIX for the suffixes of a matched switch's args when
 418         it is subsequently output with %*. SUFFIX is terminated by the next
 419         space or %.
 420  %d     marks the argument containing or following the %d as a
 421         temporary file name, so that that file will be deleted if CC exits
 422         successfully.  Unlike %g, this contributes no text to the argument.
 423  %w     marks the argument containing or following the %w as the
 424         "output file" of this compilation.  This puts the argument
 425         into the sequence of arguments that %o will substitute later.
 426  %V     indicates that this compilation produces no "output file".
 427  %W{...}
 428         like %{...} but mark last argument supplied within
 429         as a file to be deleted on failure.
 430  %o     substitutes the names of all the output files, with spaces
 431         automatically placed around them.  You should write spaces
 432         around the %o as well or the results are undefined.
 433         %o is for use in the specs for running the linker.
 434         Input files whose names have no recognized suffix are not compiled
 435         at all, but they are included among the output files, so they will
 436         be linked.
 437  %O     substitutes the suffix for object files.  Note that this is
 438         handled specially when it immediately follows %g, %u, or %U
 439         (with or without a suffix argument) because of the need for
 440         those to form complete file names.  The handling is such that
 441         %O is treated exactly as if it had already been substituted,
 442         except that %g, %u, and %U do not currently support additional
 443         SUFFIX characters following %O as they would following, for
 444         example, `.o'.
 445  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
 446         (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
 447         and -B options) as necessary.
 448  %s     current argument is the name of a library or startup file of some sort.
 449         Search for that file in a standard list of directories
 450         and substitute the full name found.
 451  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 452         Use this when inconsistent options are detected.
 453  %nSTR  Print STR as a notice.  STR is terminated by a newline.
 454  %x{OPTION}     Accumulate an option for %X.
 455  %X     Output the accumulated linker options specified by compilations.
 456  %Y     Output the accumulated assembler options specified by compilations.
 457  %Z     Output the accumulated preprocessor options specified by compilations.
 458  %a     process ASM_SPEC as a spec.
 459         This allows config.h to specify part of the spec for running as.
 460  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 461         used here.  This can be used to run a post-processor after the
 462         assembler has done its job.
 463  %D     Dump out a -L option for each directory in startfile_prefixes.
 464         If multilib_dir is set, extra entries are generated with it affixed.
 465  %l     process LINK_SPEC as a spec.
 466  %L     process LIB_SPEC as a spec.
 467  %G     process LIBGCC_SPEC as a spec.
 468  %M     output multilib_dir with directory separators replaced with "_";
 469         if multilib_dir is not set or is ".", output "".
 470  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 471  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 472  %C     process CPP_SPEC as a spec.
 473  %1     process CC1_SPEC as a spec.
 474  %2     process CC1PLUS_SPEC as a spec.
 475  %*     substitute the variable part of a matched option.  (See below.)
 476         Note that each comma in the substituted string is replaced by
 477         a single space.
 478  %<S    remove all occurrences of -S from the command line.
 479         Note - this command is position dependent.  % commands in the
 480         spec string before this one will see -S, % commands in the
 481         spec string after this one will not.
 482  %<S*   remove all occurrences of all switches beginning with -S from the
 483         command line.
 484  %:function(args)
 485         Call the named function FUNCTION, passing it ARGS.  ARGS is
 486         first processed as a nested spec string, then split into an
 487         argument vector in the usual fashion.  The function returns
 488         a string which is processed as if it had appeared literally
 489         as part of the current spec.
 490  %{S}   substitutes the -S switch, if that switch was given to CC.
 491         If that switch was not specified, this substitutes nothing.
 492         Here S is a metasyntactic variable.
 493  %{S*}  substitutes all the switches specified to CC whose names start
 494         with -S.  This is used for -o, -I, etc; switches that take
 495         arguments.  CC considers `-o foo' as being one switch whose
 496         name starts with `o'.  %{o*} would substitute this text,
 497         including the space; thus, two arguments would be generated.
 498  %{S*&T*} likewise, but preserve order of S and T options (the order
 499         of S and T in the spec is not significant).  Can be any number
 500         of ampersand-separated variables; for each the wild card is
 501         optional.  Useful for CPP as %{D*&U*&A*}.
 502
 503  %{S:X}   substitutes X, if the -S switch was given to CC.
 504  %{!S:X}  substitutes X, if the -S switch was NOT given to CC.
 505  %{S*:X}  substitutes X if one or more switches whose names start
 506           with -S was given to CC.  Normally X is substituted only
 507           once, no matter how many such switches appeared.  However,
 508           if %* appears somewhere in X, then X will be substituted
 509           once for each matching switch, with the %* replaced by the
 510           part of that switch that matched the '*'.
 511  %{.S:X}  substitutes X, if processing a file with suffix S.
 512  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
 513
 514  %{S|T:X} substitutes X if either -S or -T was given to CC.  This may be
 515           combined with !, ., and * as above binding stronger than the OR.
 516           If %* appears in X, all of the alternatives must be starred, and
 517           only the first matching alternative is substituted.
 518  %{S:X;   if S was given to CC, substitutes X;
 519    T:Y;   else if T was given to CC, substitutes Y;
 520     :D}   else substitutes D.  There can be as many clauses as you need.
 521           This may be combined with ., !, |, and * as above.
 522
 523  %(Spec) processes a specification defined in a specs file as *Spec:
 524  %[Spec] as above, but put __ around -D arguments
 525
 526 The conditional text X in a %{S:X} or similar construct may contain
 527 other nested % constructs or spaces, or even newlines.  They are
 528 processed as usual, as described above.  Trailing white space in X is
 529 ignored.  White space may also appear anywhere on the left side of the
 530 colon in these constructs, except between . or * and the corresponding
 531 word.
 532
 533 The -O, -f, -m, and -W switches are handled specifically in these
 534 constructs.  If another value of -O or the negated form of a -f, -m, or
 535 -W switch is found later in the command line, the earlier switch
 536 value is ignored, except with {S*} where S is just one letter; this
 537 passes all matching options.
 538
 539 The character | at the beginning of the predicate text is used to indicate
 540 that a command should be piped to the following command, but only if -pipe
 541 is specified.
 542
 543 Note that it is built into CC which switches take arguments and which
 544 do not.  You might think it would be useful to generalize this to
 545 allow each compiler's spec to say which switches take arguments.  But
 546 this cannot be done in a consistent fashion.  CC cannot even decide
 547 which input files have been specified without knowing which switches
 548 take arguments, and it must know which input files to compile in order
 549 to tell which compilers to run.
 550
 551 CC also knows implicitly that arguments starting in `-l' are to be
 552 treated as compiler output files, and passed to the linker in their
 553 proper position among the other output files.  */
 554 \f
 555 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
 556
 557 /* config.h can define ASM_SPEC to provide extra args to the assembler
 558    or extra switch-translations.  */
 559 #ifndef ASM_SPEC
 560 #define ASM_SPEC ""
 561 #endif
 562
 563 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 564    the assembler has run.  */
 565 #ifndef ASM_FINAL_SPEC
 566 #define ASM_FINAL_SPEC ""
 567 #endif
 568
 569 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 570    or extra switch-translations.  */
 571 #ifndef CPP_SPEC
 572 #define CPP_SPEC ""
 573 #endif
 574
 575 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 576    or extra switch-translations.  */
 577 #ifndef CC1_SPEC
 578 #define CC1_SPEC ""
 579 #endif
 580
 581 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 582    or extra switch-translations.  */
 583 #ifndef CC1PLUS_SPEC
 584 #define CC1PLUS_SPEC ""
 585 #endif
 586
 587 /* config.h can define LINK_SPEC to provide extra args to the linker
 588    or extra switch-translations.  */
 589 #ifndef LINK_SPEC
 590 #define LINK_SPEC ""
 591 #endif
 592
 593 /* config.h can define LIB_SPEC to override the default libraries.  */
 594 #ifndef LIB_SPEC
 595 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
 596 #endif
 597
 598 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
 599    included.  */
 600 #ifndef LIBGCC_SPEC
 601 #if defined(REAL_LIBGCC_SPEC)
 602 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
 603 #elif defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
 604 /* Have gcc do the search for libgcc.a.  */
 605 #define LIBGCC_SPEC "libgcc.a%s"
 606 #else
 607 #define LIBGCC_SPEC "-lgcc"
 608 #endif
 609 #endif
 610
 611 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 612 #ifndef STARTFILE_SPEC
 613 #define STARTFILE_SPEC  \
 614   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
 615 #endif
 616
 617 /* config.h can define SWITCHES_NEED_SPACES to control which options
 618    require spaces between the option and the argument.  */
 619 #ifndef SWITCHES_NEED_SPACES
 620 #define SWITCHES_NEED_SPACES ""
 621 #endif
 622
 623 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 624 #ifndef ENDFILE_SPEC
 625 #define ENDFILE_SPEC ""
 626 #endif
 627
 628 #ifndef LINKER_NAME
 629 #define LINKER_NAME "collect2"
 630 #endif
 631
 632 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
 633    to the assembler.  */
 634 #ifndef ASM_DEBUG_SPEC
 635 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
 636      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 637 #  define ASM_DEBUG_SPEC                                        \
 638       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                    \
 639        ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}"   \
 640        : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
 641 # else
 642 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 643 #   define ASM_DEBUG_SPEC "%{g*:--gstabs}"
 644 #  endif
 645 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
 646 #   define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
 647 #  endif
 648 # endif
 649 #endif
 650 #ifndef ASM_DEBUG_SPEC
 651 # define ASM_DEBUG_SPEC ""
 652 #endif
 653
 654 /* Here is the spec for running the linker, after compiling all files.  */
 655
 656 /* This is overridable by the target in case they need to specify the
 657    -lgcc and -lc order specially, yet not require them to override all
 658    of LINK_COMMAND_SPEC.  */
 659 #ifndef LINK_GCC_C_SEQUENCE_SPEC
 660 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
 661 #endif
 662
 663 #ifndef LINK_PIE_SPEC
 664 #ifdef HAVE_LD_PIE
 665 #define LINK_PIE_SPEC "%{pie:-pie} "
 666 #else
 667 #define LINK_PIE_SPEC "%{pie:} "
 668 #endif
 669 #endif
 670
 671 /* -u* was put back because both BSD and SysV seem to support it.  */
 672 /* %{static:} simply prevents an error message if the target machine
 673    doesn't handle -static.  */
 674 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 675    scripts which exist in user specified directories, or in standard
 676    directories.  */
 677 #ifndef LINK_COMMAND_SPEC
 678 #define LINK_COMMAND_SPEC "\
 679 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
 680     %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
 681     %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
 682     %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs|fprofile-generate:-lgcov}\
 683     %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
 684     %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
 685 #endif
 686
 687 #ifndef LINK_LIBGCC_SPEC
 688 # ifdef LINK_LIBGCC_SPECIAL
 689 /* Don't generate -L options for startfile prefix list.  */
 690 #  define LINK_LIBGCC_SPEC ""
 691 # else
 692 /* Do generate them.  */
 693 #  define LINK_LIBGCC_SPEC "%D"
 694 # endif
 695 #endif
 696
 697 #ifndef STARTFILE_PREFIX_SPEC
 698 # define STARTFILE_PREFIX_SPEC ""
 699 #endif
 700
 701 #ifndef SYSROOT_SUFFIX_SPEC
 702 # define SYSROOT_SUFFIX_SPEC ""
 703 #endif
 704
 705 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
 706 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
 707 #endif
 708
 709 static const char *asm_debug;
 710 static const char *cpp_spec = CPP_SPEC;
 711 static const char *cc1_spec = CC1_SPEC;
 712 static const char *cc1plus_spec = CC1PLUS_SPEC;
 713 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
 714 static const char *asm_spec = ASM_SPEC;
 715 static const char *asm_final_spec = ASM_FINAL_SPEC;
 716 static const char *link_spec = LINK_SPEC;
 717 static const char *lib_spec = LIB_SPEC;
 718 static const char *libgcc_spec = LIBGCC_SPEC;
 719 static const char *endfile_spec = ENDFILE_SPEC;
 720 static const char *startfile_spec = STARTFILE_SPEC;
 721 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
 722 static const char *linker_name_spec = LINKER_NAME;
 723 static const char *link_command_spec = LINK_COMMAND_SPEC;
 724 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
 725 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
 726 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
 727 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
 728
 729 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
 730    There should be no need to override these in target dependent files,
 731    but we need to copy them to the specs file so that newer versions
 732    of the GCC driver can correctly drive older tool chains with the
 733    appropriate -B options.  */
 734
 735 /* When cpplib handles traditional preprocessing, get rid of this, and
 736    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
 737    that we default the front end language better.  */
 738 static const char *trad_capable_cpp =
 739 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
 740
 741 /* We don't wrap .d files in %W{} since a missing .d file, and
 742    therefore no dependency entry, confuses make into thinking a .o
 743    file that happens to exist is up-to-date.  */
 744 static const char *cpp_unique_options =
 745 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
 746  %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
 747  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
 748  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
 749  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
 750  %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
 751  %{trigraphs} %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
 752  %{E|M|MM:%W{o*}}";
 753
 754 /* This contains cpp options which are common with cc1_options and are passed
 755    only when preprocessing only to avoid duplication.  We pass the cc1 spec
 756    options to the preprocessor so that it the cc1 spec may manipulate
 757    options used to set target flags.  Those special target flags settings may
 758    in turn cause preprocessor symbols to be defined specially.  */
 759 static const char *cpp_options =
 760 "%(cpp_unique_options) %1 %{m*} %{std*} %{ansi} %{W*&pedantic*} %{w} %{f*}\
 761  %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*} %{undef}";
 762
 763 /* This contains cpp options which are not passed when the preprocessor
 764    output will be used by another program.  */
 765 static const char *cpp_debug_options = "%{d*}";
 766
 767 /* NB: This is shared amongst all front-ends.  */
 768 static const char *cc1_options =
 769 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 770  %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
 771  -auxbase%{c|S:%{o*:-strip %*}%{!o*: %b}}%{!c:%{!S: %b}}\
 772  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
 773  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
 774  %{Qn:-fno-ident} %{--help:--help}\
 775  %{--target-help:--target-help}\
 776  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
 777  %{fsyntax-only:-o %j} %{-param*}";
 778
 779 static const char *asm_options =
 780 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
 781
 782 static const char *invoke_as =
 783 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
 784 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
 785 #else
 786 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
 787 #endif
 788
 789 /* Some compilers have limits on line lengths, and the multilib_select
 790    and/or multilib_matches strings can be very long, so we build them at
 791    run time.  */
 792 static struct obstack multilib_obstack;
 793 static const char *multilib_select;
 794 static const char *multilib_matches;
 795 static const char *multilib_defaults;
 796 static const char *multilib_exclusions;
 797
 798 /* Check whether a particular argument is a default argument.  */
 799
 800 #ifndef MULTILIB_DEFAULTS
 801 #define MULTILIB_DEFAULTS { "" }
 802 #endif
 803
 804 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
 805
 806 #ifndef DRIVER_SELF_SPECS
 807 #define DRIVER_SELF_SPECS ""
 808 #endif
 809
 810 static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
 811
 812 #ifndef OPTION_DEFAULT_SPECS
 813 #define OPTION_DEFAULT_SPECS { "", "" }
 814 #endif
 815
 816 struct default_spec
 817 {
 818   const char *name;
 819   const char *spec;
 820 };
 821
 822 static const struct default_spec
 823   option_default_specs[] = { OPTION_DEFAULT_SPECS };
 824
 825 struct user_specs
 826 {
 827   struct user_specs *next;
 828   const char *filename;
 829 };
 830
 831 static struct user_specs *user_specs_head, *user_specs_tail;
 832
 833 #ifndef SWITCH_TAKES_ARG
 834 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
 835 #endif
 836
 837 #ifndef WORD_SWITCH_TAKES_ARG
 838 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
 839 #endif
 840 \f
 841 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
 842 /* This defines which switches stop a full compilation.  */
 843 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
 844   ((CHAR) == 'c' || (CHAR) == 'S')
 845
 846 #ifndef SWITCH_CURTAILS_COMPILATION
 847 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
 848   DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
 849 #endif
 850 #endif
 851
 852 /* Record the mapping from file suffixes for compilation specs.  */
 853
 854 struct compiler
 855 {
 856   const char *suffix;           /* Use this compiler for input files
 857                                    whose names end in this suffix.  */
 858
 859   const char *spec;             /* To use this compiler, run this spec.  */
 860
 861   const char *cpp_spec;         /* If non-NULL, substitute this spec
 862                                    for `%C', rather than the usual
 863                                    cpp_spec.  */
 864 };
 865
 866 /* Pointer to a vector of `struct compiler' that gives the spec for
 867    compiling a file, based on its suffix.
 868    A file that does not end in any of these suffixes will be passed
 869    unchanged to the loader and nothing else will be done to it.
 870
 871    An entry containing two 0s is used to terminate the vector.
 872
 873    If multiple entries match a file, the last matching one is used.  */
 874
 875 static struct compiler *compilers;
 876
 877 /* Number of entries in `compilers', not counting the null terminator.  */
 878
 879 static int n_compilers;
 880
 881 /* The default list of file name suffixes and their compilation specs.  */
 882
 883 static const struct compiler default_compilers[] =
 884 {
 885   /* Add lists of suffixes of known languages here.  If those languages
 886      were not present when we built the driver, we will hit these copies
 887      and be given a more meaningful error than "file not used since
 888      linking is not done".  */
 889   {".m",  "#Objective-C", 0}, {".mi",  "#Objective-C", 0},
 890   {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
 891   {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
 892   {".CPP", "#C++", 0}, {".ii", "#C++", 0},
 893   {".ads", "#Ada", 0}, {".adb", "#Ada", 0},
 894   {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
 895   {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
 896   {".r", "#Ratfor", 0},
 897   {".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
 898   {".java", "#Java", 0}, {".class", "#Java", 0},
 899   {".zip", "#Java", 0}, {".jar", "#Java", 0},
 900   /* Next come the entries for C.  */
 901   {".c", "@c", 0},
 902   {"@c",
 903    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 904       external preprocessor if -save-temps is given.  */
 905      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 906       %{!E:%{!M:%{!MM:\
 907           %{traditional|ftraditional:\
 908 %eGNU C no longer supports -traditional without -E}\
 909           %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 910                 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
 911                     cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
 912                         %(cc1_options)}\
 913           %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
 914                 cc1 %(cpp_unique_options) %(cc1_options)}}}\
 915         %{!fsyntax-only:%(invoke_as)}}}}", 0},
 916   {"-",
 917    "%{!E:%e-E required when input is from standard input}\
 918     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0},
 919   {".h", "@c-header", 0},
 920   {"@c-header",
 921    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 922       external preprocessor if -save-temps is given.  */
 923      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 924       %{!E:%{!M:%{!MM:\
 925           %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 926                 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
 927                     cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
 928                         %(cc1_options)\
 929                         -o %g.s %{!o*:--output-pch=%i.gch}\
 930                         %W{o*:--output-pch=%*}%V}\
 931           %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
 932                 cc1 %(cpp_unique_options) %(cc1_options)\
 933                     -o %g.s %{!o*:--output-pch=%i.gch}\
 934                     %W{o*:--output-pch=%*}%V}}}}}}", 0},
 935   {".i", "@cpp-output", 0},
 936   {"@cpp-output",
 937    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
 938   {".s", "@assembler", 0},
 939   {"@assembler",
 940    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
 941   {".S", "@assembler-with-cpp", 0},
 942   {"@assembler-with-cpp",
 943 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
 944    "%(trad_capable_cpp) -lang-asm %(cpp_options)\
 945       %{E|M|MM:%(cpp_debug_options)}\
 946       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
 947        as %(asm_debug) %(asm_options) %|.s %A }}}}"
 948 #else
 949    "%(trad_capable_cpp) -lang-asm %(cpp_options)\
 950       %{E|M|MM:%(cpp_debug_options)}\
 951       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
 952        as %(asm_debug) %(asm_options) %m.s %A }}}}"
 953 #endif
 954    , 0},
 955
 956 #include "specs.h"
 957   /* Mark end of table.  */
 958   {0, 0, 0}
 959 };
 960
 961 /* Number of elements in default_compilers, not counting the terminator.  */
 962
 963 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
 964
 965 /* A vector of options to give to the linker.
 966    These options are accumulated by %x,
 967    and substituted into the linker command with %X.  */
 968 static int n_linker_options;
 969 static char **linker_options;
 970
 971 /* A vector of options to give to the assembler.
 972    These options are accumulated by -Wa,
 973    and substituted into the assembler command with %Y.  */
 974 static int n_assembler_options;
 975 static char **assembler_options;
 976
 977 /* A vector of options to give to the preprocessor.
 978    These options are accumulated by -Wp,
 979    and substituted into the preprocessor command with %Z.  */
 980 static int n_preprocessor_options;
 981 static char **preprocessor_options;
 982 \f
 983 /* Define how to map long options into short ones.  */
 984
 985 /* This structure describes one mapping.  */
 986 struct option_map
 987 {
 988   /* The long option's name.  */
 989   const char *const name;
 990   /* The equivalent short option.  */
 991   const char *const equivalent;
 992   /* Argument info.  A string of flag chars; NULL equals no options.
 993      a => argument required.
 994      o => argument optional.
 995      j => join argument to equivalent, making one word.
 996      * => require other text after NAME as an argument.  */
 997   const char *const arg_info;
 998 };
 999
1000 /* This is the table of mappings.  Mappings are tried sequentially
1001    for each option encountered; the first one that matches, wins.  */
1002
1003 static const struct option_map option_map[] =
1004  {
1005    {"--all-warnings", "-Wall", 0},
1006    {"--ansi", "-ansi", 0},
1007    {"--assemble", "-S", 0},
1008    {"--assert", "-A", "a"},
1009    {"--classpath", "-fclasspath=", "aj"},
1010    {"--bootclasspath", "-fbootclasspath=", "aj"},
1011    {"--CLASSPATH", "-fclasspath=", "aj"},
1012    {"--comments", "-C", 0},
1013    {"--comments-in-macros", "-CC", 0},
1014    {"--compile", "-c", 0},
1015    {"--debug", "-g", "oj"},
1016    {"--define-macro", "-D", "aj"},
1017    {"--dependencies", "-M", 0},
1018    {"--dump", "-d", "a"},
1019    {"--dumpbase", "-dumpbase", "a"},
1020    {"--entry", "-e", 0},
1021    {"--extra-warnings", "-W", 0},
1022    {"--for-assembler", "-Wa", "a"},
1023    {"--for-linker", "-Xlinker", "a"},
1024    {"--force-link", "-u", "a"},
1025    {"--imacros", "-imacros", "a"},
1026    {"--include", "-include", "a"},
1027    {"--include-barrier", "-I-", 0},
1028    {"--include-directory", "-I", "aj"},
1029    {"--include-directory-after", "-idirafter", "a"},
1030    {"--include-prefix", "-iprefix", "a"},
1031    {"--include-with-prefix", "-iwithprefix", "a"},
1032    {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1033    {"--include-with-prefix-after", "-iwithprefix", "a"},
1034    {"--language", "-x", "a"},
1035    {"--library-directory", "-L", "a"},
1036    {"--machine", "-m", "aj"},
1037    {"--machine-", "-m", "*j"},
1038    {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1039    {"--no-line-commands", "-P", 0},
1040    {"--no-precompiled-includes", "-noprecomp", 0},
1041    {"--no-standard-includes", "-nostdinc", 0},
1042    {"--no-standard-libraries", "-nostdlib", 0},
1043    {"--no-warnings", "-w", 0},
1044    {"--optimize", "-O", "oj"},
1045    {"--output", "-o", "a"},
1046    {"--output-class-directory", "-foutput-class-dir=", "ja"},
1047    {"--param", "--param", "a"},
1048    {"--pedantic", "-pedantic", 0},
1049    {"--pedantic-errors", "-pedantic-errors", 0},
1050    {"--pie", "-pie", 0},
1051    {"--pipe", "-pipe", 0},
1052    {"--prefix", "-B", "a"},
1053    {"--preprocess", "-E", 0},
1054    {"--print-search-dirs", "-print-search-dirs", 0},
1055    {"--print-file-name", "-print-file-name=", "aj"},
1056    {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1057    {"--print-missing-file-dependencies", "-MG", 0},
1058    {"--print-multi-lib", "-print-multi-lib", 0},
1059    {"--print-multi-directory", "-print-multi-directory", 0},
1060    {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1061    {"--print-prog-name", "-print-prog-name=", "aj"},
1062    {"--profile", "-p", 0},
1063    {"--profile-blocks", "-a", 0},
1064    {"--quiet", "-q", 0},
1065    {"--resource", "-fcompile-resource=", "aj"},
1066    {"--save-temps", "-save-temps", 0},
1067    {"--shared", "-shared", 0},
1068    {"--silent", "-q", 0},
1069    {"--specs", "-specs=", "aj"},
1070    {"--static", "-static", 0},
1071    {"--std", "-std=", "aj"},
1072    {"--symbolic", "-symbolic", 0},
1073    {"--time", "-time", 0},
1074    {"--trace-includes", "-H", 0},
1075    {"--traditional", "-traditional", 0},
1076    {"--traditional-cpp", "-traditional-cpp", 0},
1077    {"--trigraphs", "-trigraphs", 0},
1078    {"--undefine-macro", "-U", "aj"},
1079    {"--user-dependencies", "-MM", 0},
1080    {"--verbose", "-v", 0},
1081    {"--warn-", "-W", "*j"},
1082    {"--write-dependencies", "-MD", 0},
1083    {"--write-user-dependencies", "-MMD", 0},
1084    {"--", "-f", "*j"}
1085  };
1086 \f
1087
1088 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1089 static const struct {
1090   const char *const option_found;
1091   const char *const replacements;
1092 } target_option_translations[] =
1093 {
1094   TARGET_OPTION_TRANSLATE_TABLE,
1095   { 0, 0 }
1096 };
1097 #endif
1098
1099 /* Translate the options described by *ARGCP and *ARGVP.
1100    Make a new vector and store it back in *ARGVP,
1101    and store its length in *ARGVC.  */
1102
1103 static void
1104 translate_options (int *argcp, const char *const **argvp)
1105 {
1106   int i;
1107   int argc = *argcp;
1108   const char *const *argv = *argvp;
1109   int newvsize = (argc + 2) * 2 * sizeof (const char *);
1110   const char **newv = xmalloc (newvsize);
1111   int newindex = 0;
1112
1113   i = 0;
1114   newv[newindex++] = argv[i++];
1115
1116   while (i < argc)
1117     {
1118 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1119       int tott_idx;
1120
1121       for (tott_idx = 0;
1122            target_option_translations[tott_idx].option_found;
1123            tott_idx++)
1124         {
1125           if (strcmp (target_option_translations[tott_idx].option_found,
1126                       argv[i]) == 0)
1127             {
1128               int spaces = 1;
1129               const char *sp;
1130               char *np;
1131
1132               for (sp = target_option_translations[tott_idx].replacements;
1133                    *sp; sp++)
1134                 {
1135                   if (*sp == ' ')
1136                     spaces ++;
1137                 }
1138
1139               newvsize += spaces * sizeof (const char *);
1140               newv =  xrealloc (newv, newvsize);
1141
1142               sp = target_option_translations[tott_idx].replacements;
1143               np = xstrdup (sp);
1144
1145               while (1)
1146                 {
1147                   while (*np == ' ')
1148                     np++;
1149                   if (*np == 0)
1150                     break;
1151                   newv[newindex++] = np;
1152                   while (*np != ' ' && *np)
1153                     np++;
1154                   if (*np == 0)
1155                     break;
1156                   *np++ = 0;
1157                 }
1158
1159               i ++;
1160               break;
1161             }
1162         }
1163       if (target_option_translations[tott_idx].option_found)
1164         continue;
1165 #endif
1166
1167       /* Translate -- options.  */
1168       if (argv[i][0] == '-' && argv[i][1] == '-')
1169         {
1170           size_t j;
1171           /* Find a mapping that applies to this option.  */
1172           for (j = 0; j < ARRAY_SIZE (option_map); j++)
1173             {
1174               size_t optlen = strlen (option_map[j].name);
1175               size_t arglen = strlen (argv[i]);
1176               size_t complen = arglen > optlen ? optlen : arglen;
1177               const char *arginfo = option_map[j].arg_info;
1178
1179               if (arginfo == 0)
1180                 arginfo = "";
1181
1182               if (!strncmp (argv[i], option_map[j].name, complen))
1183                 {
1184                   const char *arg = 0;
1185
1186                   if (arglen < optlen)
1187                     {
1188                       size_t k;
1189                       for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1190                         if (strlen (option_map[k].name) >= arglen
1191                             && !strncmp (argv[i], option_map[k].name, arglen))
1192                           {
1193                             error ("ambiguous abbreviation %s", argv[i]);
1194                             break;
1195                           }
1196
1197                       if (k != ARRAY_SIZE (option_map))
1198                         break;
1199                     }
1200
1201                   if (arglen > optlen)
1202                     {
1203                       /* If the option has an argument, accept that.  */
1204                       if (argv[i][optlen] == '=')
1205                         arg = argv[i] + optlen + 1;
1206
1207                       /* If this mapping requires extra text at end of name,
1208                          accept that as "argument".  */
1209                       else if (strchr (arginfo, '*') != 0)
1210                         arg = argv[i] + optlen;
1211
1212                       /* Otherwise, extra text at end means mismatch.
1213                          Try other mappings.  */
1214                       else
1215                         continue;
1216                     }
1217
1218                   else if (strchr (arginfo, '*') != 0)
1219                     {
1220                       error ("incomplete `%s' option", option_map[j].name);
1221                       break;
1222                     }
1223
1224                   /* Handle arguments.  */
1225                   if (strchr (arginfo, 'a') != 0)
1226                     {
1227                       if (arg == 0)
1228                         {
1229                           if (i + 1 == argc)
1230                             {
1231                               error ("missing argument to `%s' option",
1232                                      option_map[j].name);
1233                               break;
1234                             }
1235
1236                           arg = argv[++i];
1237                         }
1238                     }
1239                   else if (strchr (arginfo, '*') != 0)
1240                     ;
1241                   else if (strchr (arginfo, 'o') == 0)
1242                     {
1243                       if (arg != 0)
1244                         error ("extraneous argument to `%s' option",
1245                                option_map[j].name);
1246                       arg = 0;
1247                     }
1248
1249                   /* Store the translation as one argv elt or as two.  */
1250                   if (arg != 0 && strchr (arginfo, 'j') != 0)
1251                     newv[newindex++] = concat (option_map[j].equivalent, arg,
1252                                                NULL);
1253                   else if (arg != 0)
1254                     {
1255                       newv[newindex++] = option_map[j].equivalent;
1256                       newv[newindex++] = arg;
1257                     }
1258                   else
1259                     newv[newindex++] = option_map[j].equivalent;
1260
1261                   break;
1262                 }
1263             }
1264           i++;
1265         }
1266
1267       /* Handle old-fashioned options--just copy them through,
1268          with their arguments.  */
1269       else if (argv[i][0] == '-')
1270         {
1271           const char *p = argv[i] + 1;
1272           int c = *p;
1273           int nskip = 1;
1274
1275           if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1276             nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1277           else if (WORD_SWITCH_TAKES_ARG (p))
1278             nskip += WORD_SWITCH_TAKES_ARG (p);
1279           else if ((c == 'B' || c == 'b' || c == 'x')
1280                    && p[1] == 0)
1281             nskip += 1;
1282           else if (! strcmp (p, "Xlinker"))
1283             nskip += 1;
1284           else if (! strcmp (p, "Xpreprocessor"))
1285             nskip += 1;
1286           else if (! strcmp (p, "Xassembler"))
1287             nskip += 1;
1288
1289           /* Watch out for an option at the end of the command line that
1290              is missing arguments, and avoid skipping past the end of the
1291              command line.  */
1292           if (nskip + i > argc)
1293             nskip = argc - i;
1294
1295           while (nskip > 0)
1296             {
1297               newv[newindex++] = argv[i++];
1298               nskip--;
1299             }
1300         }
1301       else
1302         /* Ordinary operands, or +e options.  */
1303         newv[newindex++] = argv[i++];
1304     }
1305
1306   newv[newindex] = 0;
1307
1308   *argvp = newv;
1309   *argcp = newindex;
1310 }
1311 \f
1312 static char *
1313 skip_whitespace (char *p)
1314 {
1315   while (1)
1316     {
1317       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1318          be considered whitespace.  */
1319       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1320         return p + 1;
1321       else if (*p == '\n' || *p == ' ' || *p == '\t')
1322         p++;
1323       else if (*p == '#')
1324         {
1325           while (*p != '\n')
1326             p++;
1327           p++;
1328         }
1329       else
1330         break;
1331     }
1332
1333   return p;
1334 }
1335 /* Structures to keep track of prefixes to try when looking for files.  */
1336
1337 struct prefix_list
1338 {
1339   const char *prefix;         /* String to prepend to the path.  */
1340   struct prefix_list *next;   /* Next in linked list.  */
1341   int require_machine_suffix; /* Don't use without machine_suffix.  */
1342   /* 2 means try both machine_suffix and just_machine_suffix.  */
1343   int *used_flag_ptr;         /* 1 if a file was found with this prefix.  */
1344   int priority;               /* Sort key - priority within list.  */
1345   int os_multilib;            /* 1 if OS multilib scheme should be used,
1346                                  0 for GCC multilib scheme.  */
1347 };
1348
1349 struct path_prefix
1350 {
1351   struct prefix_list *plist;  /* List of prefixes to try */
1352   int max_len;                /* Max length of a prefix in PLIST */
1353   const char *name;           /* Name of this list (used in config stuff) */
1354 };
1355
1356 /* List of prefixes to try when looking for executables.  */
1357
1358 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1359
1360 /* List of prefixes to try when looking for startup (crt0) files.  */
1361
1362 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1363
1364 /* List of prefixes to try when looking for include files.  */
1365
1366 static struct path_prefix include_prefixes = { 0, 0, "include" };
1367
1368 /* Suffix to attach to directories searched for commands.
1369    This looks like `MACHINE/VERSION/'.  */
1370
1371 static const char *machine_suffix = 0;
1372
1373 /* Suffix to attach to directories searched for commands.
1374    This is just `MACHINE/'.  */
1375
1376 static const char *just_machine_suffix = 0;
1377
1378 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1379
1380 static const char *gcc_exec_prefix;
1381
1382 /* Adjusted value of standard_libexec_prefix.  */
1383
1384 static const char *gcc_libexec_prefix;
1385
1386 /* Default prefixes to attach to command names.  */
1387
1388 #ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
1389 #undef MD_EXEC_PREFIX
1390 #undef MD_STARTFILE_PREFIX
1391 #undef MD_STARTFILE_PREFIX_1
1392 #endif
1393
1394 /* If no prefixes defined, use the null string, which will disable them.  */
1395 #ifndef MD_EXEC_PREFIX
1396 #define MD_EXEC_PREFIX ""
1397 #endif
1398 #ifndef MD_STARTFILE_PREFIX
1399 #define MD_STARTFILE_PREFIX ""
1400 #endif
1401 #ifndef MD_STARTFILE_PREFIX_1
1402 #define MD_STARTFILE_PREFIX_1 ""
1403 #endif
1404
1405 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1406 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1407 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
1408 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1409
1410 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1411 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1412 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1413 static const char *const standard_startfile_prefix_1 = "/lib/";
1414 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1415
1416 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1417 static const char *tooldir_prefix;
1418
1419 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1420
1421 static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1422
1423 /* Subdirectory to use for locating libraries.  Set by
1424    set_multilib_dir based on the compilation options.  */
1425
1426 static const char *multilib_dir;
1427
1428 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1429    set_multilib_dir based on the compilation options.  */
1430
1431 static const char *multilib_os_dir;
1432 \f
1433 /* Structure to keep track of the specs that have been defined so far.
1434    These are accessed using %(specname) or %[specname] in a compiler
1435    or link spec.  */
1436
1437 struct spec_list
1438 {
1439                                 /* The following 2 fields must be first */
1440                                 /* to allow EXTRA_SPECS to be initialized */
1441   const char *name;             /* name of the spec.  */
1442   const char *ptr;              /* available ptr if no static pointer */
1443
1444                                 /* The following fields are not initialized */
1445                                 /* by EXTRA_SPECS */
1446   const char **ptr_spec;        /* pointer to the spec itself.  */
1447   struct spec_list *next;       /* Next spec in linked list.  */
1448   int name_len;                 /* length of the name */
1449   int alloc_p;                  /* whether string was allocated */
1450 };
1451
1452 #define INIT_STATIC_SPEC(NAME,PTR) \
1453 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1454
1455 /* List of statically defined specs.  */
1456 static struct spec_list static_specs[] =
1457 {
1458   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1459   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1460   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1461   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1462   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1463   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1464   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1465   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1466   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1467   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1468   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1469   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1470   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1471   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1472   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1473   INIT_STATIC_SPEC ("link",                     &link_spec),
1474   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1475   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1476   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1477   INIT_STATIC_SPEC ("switches_need_spaces",     &switches_need_spaces),
1478   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1479   INIT_STATIC_SPEC ("version",                  &compiler_version),
1480   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1481   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1482   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1483   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1484   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1485   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1486   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1487   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1488   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1489   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1490   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1491   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1492   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1493   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1494 };
1495
1496 #ifdef EXTRA_SPECS              /* additional specs needed */
1497 /* Structure to keep track of just the first two args of a spec_list.
1498    That is all that the EXTRA_SPECS macro gives us.  */
1499 struct spec_list_1
1500 {
1501   const char *const name;
1502   const char *const ptr;
1503 };
1504
1505 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1506 static struct spec_list *extra_specs = (struct spec_list *) 0;
1507 #endif
1508
1509 /* List of dynamically allocates specs that have been defined so far.  */
1510
1511 static struct spec_list *specs = (struct spec_list *) 0;
1512 \f
1513 /* List of static spec functions.  */
1514
1515 static const struct spec_function static_spec_functions[] =
1516 {
1517   { "if-exists",                if_exists_spec_function },
1518   { "if-exists-else",           if_exists_else_spec_function },
1519   { 0, 0 }
1520 };
1521
1522 static int processing_spec_function;
1523 \f
1524 /* Add appropriate libgcc specs to OBSTACK, taking into account
1525    various permutations of -shared-libgcc, -shared, and such.  */
1526
1527 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1528 static void
1529 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1530                 const char *static_name, const char *eh_name)
1531 {
1532   char *buf;
1533
1534   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1535                 "}%{!static:%{!static-libgcc:",
1536                 "%{!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 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
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                             ,
1639                             "-lgcc",
1640                             "-lgcc_eh"
1641 #ifdef USE_LIBUNWIND_EXCEPTIONS
1642                             " -lunwind"
1643 #endif
1644                             );
1645
1646             p += 5;
1647             in_sep = 0;
1648           }
1649         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1650           {
1651             /* Ug.  We don't know shared library extensions.  Hope that
1652                systems that use this form don't do shared libraries.  */
1653             init_gcc_specs (&obstack,
1654 #ifdef NO_SHARED_LIBGCC_MULTILIB
1655                             "-lgcc_s"
1656 #else
1657                             "-lgcc_s%M"
1658 #endif
1659                             ,
1660                             "libgcc.a%s",
1661                             "libgcc_eh.a%s"
1662 #ifdef USE_LIBUNWIND_EXCEPTIONS
1663                             " -lunwind"
1664 #endif
1665                             );
1666             p += 10;
1667             in_sep = 0;
1668           }
1669         else
1670           {
1671             obstack_1grow (&obstack, *p);
1672             in_sep = (*p == ' ');
1673             p += 1;
1674           }
1675       }
1676
1677     obstack_1grow (&obstack, '\0');
1678     libgcc_spec = obstack_finish (&obstack);
1679   }
1680 #endif
1681 #ifdef USE_AS_TRADITIONAL_FORMAT
1682   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1683   {
1684     static const char tf[] = "--traditional-format ";
1685     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1686     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1687     asm_spec = obstack_finish (&obstack);
1688   }
1689 #endif
1690 #ifdef LINK_EH_SPEC
1691   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1692   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1693   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1694   link_spec = obstack_finish (&obstack);
1695 #endif
1696
1697   specs = sl;
1698 }
1699 \f
1700 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1701    removed; If the spec starts with a + then SPEC is added to the end of the
1702    current spec.  */
1703
1704 static void
1705 set_spec (const char *name, const char *spec)
1706 {
1707   struct spec_list *sl;
1708   const char *old_spec;
1709   int name_len = strlen (name);
1710   int i;
1711
1712   /* If this is the first call, initialize the statically allocated specs.  */
1713   if (!specs)
1714     {
1715       struct spec_list *next = (struct spec_list *) 0;
1716       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1717         {
1718           sl = &static_specs[i];
1719           sl->next = next;
1720           next = sl;
1721         }
1722       specs = sl;
1723     }
1724
1725   /* See if the spec already exists.  */
1726   for (sl = specs; sl; sl = sl->next)
1727     if (name_len == sl->name_len && !strcmp (sl->name, name))
1728       break;
1729
1730   if (!sl)
1731     {
1732       /* Not found - make it.  */
1733       sl = xmalloc (sizeof (struct spec_list));
1734       sl->name = xstrdup (name);
1735       sl->name_len = name_len;
1736       sl->ptr_spec = &sl->ptr;
1737       sl->alloc_p = 0;
1738       *(sl->ptr_spec) = "";
1739       sl->next = specs;
1740       specs = sl;
1741     }
1742
1743   old_spec = *(sl->ptr_spec);
1744   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1745                      ? concat (old_spec, spec + 1, NULL)
1746                      : xstrdup (spec));
1747
1748 #ifdef DEBUG_SPECS
1749   if (verbose_flag)
1750     notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1751 #endif
1752
1753   /* Free the old spec.  */
1754   if (old_spec && sl->alloc_p)
1755     free ((void *) old_spec);
1756
1757   sl->alloc_p = 1;
1758 }
1759 \f
1760 /* Accumulate a command (program name and args), and run it.  */
1761
1762 /* Vector of pointers to arguments in the current line of specifications.  */
1763
1764 static const char **argbuf;
1765
1766 /* Number of elements allocated in argbuf.  */
1767
1768 static int argbuf_length;
1769
1770 /* Number of elements in argbuf currently in use (containing args).  */
1771
1772 static int argbuf_index;
1773
1774 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1775    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1776    it here.  */
1777
1778 static struct temp_name {
1779   const char *suffix;   /* suffix associated with the code.  */
1780   int length;           /* strlen (suffix).  */
1781   int unique;           /* Indicates whether %g or %u/%U was used.  */
1782   const char *filename; /* associated filename.  */
1783   int filename_length;  /* strlen (filename).  */
1784   struct temp_name *next;
1785 } *temp_names;
1786
1787 /* Number of commands executed so far.  */
1788
1789 static int execution_count;
1790
1791 /* Number of commands that exited with a signal.  */
1792
1793 static int signal_count;
1794
1795 /* Name with which this program was invoked.  */
1796
1797 static const char *programname;
1798 \f
1799 /* Allocate the argument vector.  */
1800
1801 static void
1802 alloc_args (void)
1803 {
1804   argbuf_length = 10;
1805   argbuf = xmalloc (argbuf_length * sizeof (const char *));
1806 }
1807
1808 /* Clear out the vector of arguments (after a command is executed).  */
1809
1810 static void
1811 clear_args (void)
1812 {
1813   argbuf_index = 0;
1814 }
1815
1816 /* Add one argument to the vector at the end.
1817    This is done when a space is seen or at the end of the line.
1818    If DELETE_ALWAYS is nonzero, the arg is a filename
1819     and the file should be deleted eventually.
1820    If DELETE_FAILURE is nonzero, the arg is a filename
1821     and the file should be deleted if this compilation fails.  */
1822
1823 static void
1824 store_arg (const char *arg, int delete_always, int delete_failure)
1825 {
1826   if (argbuf_index + 1 == argbuf_length)
1827     argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1828
1829   argbuf[argbuf_index++] = arg;
1830   argbuf[argbuf_index] = 0;
1831
1832   if (delete_always || delete_failure)
1833     record_temp_file (arg, delete_always, delete_failure);
1834 }
1835 \f
1836 /* Load specs from a file name named FILENAME, replacing occurrences of
1837    various different types of line-endings, \r\n, \n\r and just \r, with
1838    a single \n.  */
1839
1840 static char *
1841 load_specs (const char *filename)
1842 {
1843   int desc;
1844   int readlen;
1845   struct stat statbuf;
1846   char *buffer;
1847   char *buffer_p;
1848   char *specs;
1849   char *specs_p;
1850
1851   if (verbose_flag)
1852     notice ("Reading specs from %s\n", filename);
1853
1854   /* Open and stat the file.  */
1855   desc = open (filename, O_RDONLY, 0);
1856   if (desc < 0)
1857     pfatal_with_name (filename);
1858   if (stat (filename, &statbuf) < 0)
1859     pfatal_with_name (filename);
1860
1861   /* Read contents of file into BUFFER.  */
1862   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1863   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1864   if (readlen < 0)
1865     pfatal_with_name (filename);
1866   buffer[readlen] = 0;
1867   close (desc);
1868
1869   specs = xmalloc (readlen + 1);
1870   specs_p = specs;
1871   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1872     {
1873       int skip = 0;
1874       char c = *buffer_p;
1875       if (c == '\r')
1876         {
1877           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1878             skip = 1;
1879           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1880             skip = 1;
1881           else                                                  /* \r */
1882             c = '\n';
1883         }
1884       if (! skip)
1885         *specs_p++ = c;
1886     }
1887   *specs_p = '\0';
1888
1889   free (buffer);
1890   return (specs);
1891 }
1892
1893 /* Read compilation specs from a file named FILENAME,
1894    replacing the default ones.
1895
1896    A suffix which starts with `*' is a definition for
1897    one of the machine-specific sub-specs.  The "suffix" should be
1898    *asm, *cc1, *cpp, *link, *startfile, etc.
1899    The corresponding spec is stored in asm_spec, etc.,
1900    rather than in the `compilers' vector.
1901
1902    Anything invalid in the file is a fatal error.  */
1903
1904 static void
1905 read_specs (const char *filename, int main_p)
1906 {
1907   char *buffer;
1908   char *p;
1909
1910   buffer = load_specs (filename);
1911
1912   /* Scan BUFFER for specs, putting them in the vector.  */
1913   p = buffer;
1914   while (1)
1915     {
1916       char *suffix;
1917       char *spec;
1918       char *in, *out, *p1, *p2, *p3;
1919
1920       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1921       p = skip_whitespace (p);
1922       if (*p == 0)
1923         break;
1924
1925       /* Is this a special command that starts with '%'? */
1926       /* Don't allow this for the main specs file, since it would
1927          encourage people to overwrite it.  */
1928       if (*p == '%' && !main_p)
1929         {
1930           p1 = p;
1931           while (*p && *p != '\n')
1932             p++;
1933
1934           /* Skip '\n'.  */
1935           p++;
1936
1937           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1938               && (p1[sizeof "%include" - 1] == ' '
1939                   || p1[sizeof "%include" - 1] == '\t'))
1940             {
1941               char *new_filename;
1942
1943               p1 += sizeof ("%include");
1944               while (*p1 == ' ' || *p1 == '\t')
1945                 p1++;
1946
1947               if (*p1++ != '<' || p[-2] != '>')
1948                 fatal ("specs %%include syntax malformed after %ld characters",
1949                        (long) (p1 - buffer + 1));
1950
1951               p[-2] = '\0';
1952               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
1953               read_specs (new_filename ? new_filename : p1, FALSE);
1954               continue;
1955             }
1956           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1957                    && (p1[sizeof "%include_noerr" - 1] == ' '
1958                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1959             {
1960               char *new_filename;
1961
1962               p1 += sizeof "%include_noerr";
1963               while (*p1 == ' ' || *p1 == '\t')
1964                 p1++;
1965
1966               if (*p1++ != '<' || p[-2] != '>')
1967                 fatal ("specs %%include syntax malformed after %ld characters",
1968                        (long) (p1 - buffer + 1));
1969
1970               p[-2] = '\0';
1971               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
1972               if (new_filename)
1973                 read_specs (new_filename, FALSE);
1974               else if (verbose_flag)
1975                 notice ("could not find specs file %s\n", p1);
1976               continue;
1977             }
1978           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1979                    && (p1[sizeof "%rename" - 1] == ' '
1980                        || p1[sizeof "%rename" - 1] == '\t'))
1981             {
1982               int name_len;
1983               struct spec_list *sl;
1984               struct spec_list *newsl;
1985
1986               /* Get original name.  */
1987               p1 += sizeof "%rename";
1988               while (*p1 == ' ' || *p1 == '\t')
1989                 p1++;
1990
1991               if (! ISALPHA ((unsigned char) *p1))
1992                 fatal ("specs %%rename syntax malformed after %ld characters",
1993                        (long) (p1 - buffer));
1994
1995               p2 = p1;
1996               while (*p2 && !ISSPACE ((unsigned char) *p2))
1997                 p2++;
1998
1999               if (*p2 != ' ' && *p2 != '\t')
2000                 fatal ("specs %%rename syntax malformed after %ld characters",
2001                        (long) (p2 - buffer));
2002
2003               name_len = p2 - p1;
2004               *p2++ = '\0';
2005               while (*p2 == ' ' || *p2 == '\t')
2006                 p2++;
2007
2008               if (! ISALPHA ((unsigned char) *p2))
2009                 fatal ("specs %%rename syntax malformed after %ld characters",
2010                        (long) (p2 - buffer));
2011
2012               /* Get new spec name.  */
2013               p3 = p2;
2014               while (*p3 && !ISSPACE ((unsigned char) *p3))
2015                 p3++;
2016
2017               if (p3 != p - 1)
2018                 fatal ("specs %%rename syntax malformed after %ld characters",
2019                        (long) (p3 - buffer));
2020               *p3 = '\0';
2021
2022               for (sl = specs; sl; sl = sl->next)
2023                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2024                   break;
2025
2026               if (!sl)
2027                 fatal ("specs %s spec was not found to be renamed", p1);
2028
2029               if (strcmp (p1, p2) == 0)
2030                 continue;
2031
2032               for (newsl = specs; newsl; newsl = newsl->next)
2033                 if (strcmp (newsl->name, p2) == 0)
2034                   fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2035                     filename, p1, p2);
2036
2037               if (verbose_flag)
2038                 {
2039                   notice ("rename spec %s to %s\n", p1, p2);
2040 #ifdef DEBUG_SPECS
2041                   notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2042 #endif
2043                 }
2044
2045               set_spec (p2, *(sl->ptr_spec));
2046               if (sl->alloc_p)
2047                 free ((void *) *(sl->ptr_spec));
2048
2049               *(sl->ptr_spec) = "";
2050               sl->alloc_p = 0;
2051               continue;
2052             }
2053           else
2054             fatal ("specs unknown %% command after %ld characters",
2055                    (long) (p1 - buffer));
2056         }
2057
2058       /* Find the colon that should end the suffix.  */
2059       p1 = p;
2060       while (*p1 && *p1 != ':' && *p1 != '\n')
2061         p1++;
2062
2063       /* The colon shouldn't be missing.  */
2064       if (*p1 != ':')
2065         fatal ("specs file malformed after %ld characters",
2066                (long) (p1 - buffer));
2067
2068       /* Skip back over trailing whitespace.  */
2069       p2 = p1;
2070       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2071         p2--;
2072
2073       /* Copy the suffix to a string.  */
2074       suffix = save_string (p, p2 - p);
2075       /* Find the next line.  */
2076       p = skip_whitespace (p1 + 1);
2077       if (p[1] == 0)
2078         fatal ("specs file malformed after %ld characters",
2079                (long) (p - buffer));
2080
2081       p1 = p;
2082       /* Find next blank line or end of string.  */
2083       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2084         p1++;
2085
2086       /* Specs end at the blank line and do not include the newline.  */
2087       spec = save_string (p, p1 - p);
2088       p = p1;
2089
2090       /* Delete backslash-newline sequences from the spec.  */
2091       in = spec;
2092       out = spec;
2093       while (*in != 0)
2094         {
2095           if (in[0] == '\\' && in[1] == '\n')
2096             in += 2;
2097           else if (in[0] == '#')
2098             while (*in && *in != '\n')
2099               in++;
2100
2101           else
2102             *out++ = *in++;
2103         }
2104       *out = 0;
2105
2106       if (suffix[0] == '*')
2107         {
2108           if (! strcmp (suffix, "*link_command"))
2109             link_command_spec = spec;
2110           else
2111             set_spec (suffix + 1, spec);
2112         }
2113       else
2114         {
2115           /* Add this pair to the vector.  */
2116           compilers
2117             = xrealloc (compilers,
2118                         (n_compilers + 2) * sizeof (struct compiler));
2119
2120           compilers[n_compilers].suffix = suffix;
2121           compilers[n_compilers].spec = spec;
2122           n_compilers++;
2123           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2124         }
2125
2126       if (*suffix == 0)
2127         link_command_spec = spec;
2128     }
2129
2130   if (link_command_spec == 0)
2131     fatal ("spec file has no spec for linking");
2132 }
2133 \f
2134 /* Record the names of temporary files we tell compilers to write,
2135    and delete them at the end of the run.  */
2136
2137 /* This is the common prefix we use to make temp file names.
2138    It is chosen once for each run of this program.
2139    It is substituted into a spec by %g or %j.
2140    Thus, all temp file names contain this prefix.
2141    In practice, all temp file names start with this prefix.
2142
2143    This prefix comes from the envvar TMPDIR if it is defined;
2144    otherwise, from the P_tmpdir macro if that is defined;
2145    otherwise, in /usr/tmp or /tmp;
2146    or finally the current directory if all else fails.  */
2147
2148 static const char *temp_filename;
2149
2150 /* Length of the prefix.  */
2151
2152 static int temp_filename_length;
2153
2154 /* Define the list of temporary files to delete.  */
2155
2156 struct temp_file
2157 {
2158   const char *name;
2159   struct temp_file *next;
2160 };
2161
2162 /* Queue of files to delete on success or failure of compilation.  */
2163 static struct temp_file *always_delete_queue;
2164 /* Queue of files to delete on failure of compilation.  */
2165 static struct temp_file *failure_delete_queue;
2166
2167 /* Record FILENAME as a file to be deleted automatically.
2168    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2169    otherwise delete it in any case.
2170    FAIL_DELETE nonzero means delete it if a compilation step fails;
2171    otherwise delete it in any case.  */
2172
2173 void
2174 record_temp_file (const char *filename, int always_delete, int fail_delete)
2175 {
2176   char *const name = xstrdup (filename);
2177
2178   if (always_delete)
2179     {
2180       struct temp_file *temp;
2181       for (temp = always_delete_queue; temp; temp = temp->next)
2182         if (! strcmp (name, temp->name))
2183           goto already1;
2184
2185       temp = xmalloc (sizeof (struct temp_file));
2186       temp->next = always_delete_queue;
2187       temp->name = name;
2188       always_delete_queue = temp;
2189
2190     already1:;
2191     }
2192
2193   if (fail_delete)
2194     {
2195       struct temp_file *temp;
2196       for (temp = failure_delete_queue; temp; temp = temp->next)
2197         if (! strcmp (name, temp->name))
2198           goto already2;
2199
2200       temp = xmalloc (sizeof (struct temp_file));
2201       temp->next = failure_delete_queue;
2202       temp->name = name;
2203       failure_delete_queue = temp;
2204
2205     already2:;
2206     }
2207 }
2208
2209 /* Delete all the temporary files whose names we previously recorded.  */
2210
2211 static void
2212 delete_if_ordinary (const char *name)
2213 {
2214   struct stat st;
2215 #ifdef DEBUG
2216   int i, c;
2217
2218   printf ("Delete %s? (y or n) ", name);
2219   fflush (stdout);
2220   i = getchar ();
2221   if (i != '\n')
2222     while ((c = getchar ()) != '\n' && c != EOF)
2223       ;
2224
2225   if (i == 'y' || i == 'Y')
2226 #endif /* DEBUG */
2227     if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
2228       if (unlink (name) < 0)
2229         if (verbose_flag)
2230           perror_with_name (name);
2231 }
2232
2233 static void
2234 delete_temp_files (void)
2235 {
2236   struct temp_file *temp;
2237
2238   for (temp = always_delete_queue; temp; temp = temp->next)
2239     delete_if_ordinary (temp->name);
2240   always_delete_queue = 0;
2241 }
2242
2243 /* Delete all the files to be deleted on error.  */
2244
2245 static void
2246 delete_failure_queue (void)
2247 {
2248   struct temp_file *temp;
2249
2250   for (temp = failure_delete_queue; temp; temp = temp->next)
2251     delete_if_ordinary (temp->name);
2252 }
2253
2254 static void
2255 clear_failure_queue (void)
2256 {
2257   failure_delete_queue = 0;
2258 }
2259 \f
2260 /* Build a list of search directories from PATHS.
2261    PREFIX is a string to prepend to the list.
2262    If CHECK_DIR_P is nonzero we ensure the directory exists.
2263    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2264    It is also used by the --print-search-dirs flag.  */
2265
2266 static char *
2267 build_search_list (struct path_prefix *paths, const char *prefix,
2268                    int check_dir_p)
2269 {
2270   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2271   int just_suffix_len
2272     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2273   int first_time = TRUE;
2274   struct prefix_list *pprefix;
2275
2276   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2277   obstack_1grow (&collect_obstack, '=');
2278
2279   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2280     {
2281       int len = strlen (pprefix->prefix);
2282
2283       if (machine_suffix
2284           && (! check_dir_p
2285               || is_directory (pprefix->prefix, machine_suffix, 0)))
2286         {
2287           if (!first_time)
2288             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2289
2290           first_time = FALSE;
2291           obstack_grow (&collect_obstack, pprefix->prefix, len);
2292           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2293         }
2294
2295       if (just_machine_suffix
2296           && pprefix->require_machine_suffix == 2
2297           && (! check_dir_p
2298               || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2299         {
2300           if (! first_time)
2301             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2302
2303           first_time = FALSE;
2304           obstack_grow (&collect_obstack, pprefix->prefix, len);
2305           obstack_grow (&collect_obstack, just_machine_suffix,
2306                         just_suffix_len);
2307         }
2308
2309       if (! pprefix->require_machine_suffix)
2310         {
2311           if (! first_time)
2312             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2313
2314           first_time = FALSE;
2315           obstack_grow (&collect_obstack, pprefix->prefix, len);
2316         }
2317     }
2318
2319   obstack_1grow (&collect_obstack, '\0');
2320   return obstack_finish (&collect_obstack);
2321 }
2322
2323 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2324    for collect.  */
2325
2326 static void
2327 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2328 {
2329   putenv (build_search_list (paths, env_var, 1));
2330 }
2331 \f
2332 /* Check whether NAME can be accessed in MODE.  This is like access,
2333    except that it never considers directories to be executable.  */
2334
2335 static int
2336 access_check (const char *name, int mode)
2337 {
2338   if (mode == X_OK)
2339     {
2340       struct stat st;
2341
2342       if (stat (name, &st) < 0
2343           || S_ISDIR (st.st_mode))
2344         return -1;
2345     }
2346
2347   return access (name, mode);
2348 }
2349
2350 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2351    access to check permissions.
2352    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2353
2354 static char *
2355 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2356              int multilib)
2357 {
2358   char *temp;
2359   const char *const file_suffix =
2360     ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2361   struct prefix_list *pl;
2362   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2363   const char *multilib_name, *multilib_os_name;
2364
2365 #ifdef DEFAULT_ASSEMBLER
2366   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2367     return xstrdup (DEFAULT_ASSEMBLER);
2368 #endif
2369
2370 #ifdef DEFAULT_LINKER
2371   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2372     return xstrdup (DEFAULT_LINKER);
2373 #endif
2374
2375   if (machine_suffix)
2376     len += strlen (machine_suffix);
2377
2378   multilib_name = name;
2379   multilib_os_name = name;
2380   if (multilib && multilib_os_dir)
2381     {
2382       int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2383       int len2 = strlen (multilib_os_dir) + 1;
2384
2385       len += len1 > len2 ? len1 : len2;
2386       if (multilib_dir)
2387         multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2388                                   NULL));
2389       if (strcmp (multilib_os_dir, ".") != 0)
2390         multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2391                                     NULL));
2392     }
2393
2394   temp = xmalloc (len);
2395
2396   /* Determine the filename to execute (special case for absolute paths).  */
2397
2398   if (IS_ABSOLUTE_PATH (name))
2399     {
2400       if (access (name, mode) == 0)
2401         {
2402           strcpy (temp, name);
2403           return temp;
2404         }
2405     }
2406   else
2407     for (pl = pprefix->plist; pl; pl = pl->next)
2408       {
2409         const char *this_name
2410           = pl->os_multilib ? multilib_os_name : multilib_name;
2411
2412         if (machine_suffix)
2413           {
2414             /* Some systems have a suffix for executable files.
2415                So try appending that first.  */
2416             if (file_suffix[0] != 0)
2417               {
2418                 strcpy (temp, pl->prefix);
2419                 strcat (temp, machine_suffix);
2420                 strcat (temp, multilib_name);
2421                 strcat (temp, file_suffix);
2422                 if (access_check (temp, mode) == 0)
2423                   {
2424                     if (pl->used_flag_ptr != 0)
2425                       *pl->used_flag_ptr = 1;
2426                     return temp;
2427                   }
2428               }
2429
2430             /* Now try just the multilib_name.  */
2431             strcpy (temp, pl->prefix);
2432             strcat (temp, machine_suffix);
2433             strcat (temp, multilib_name);
2434             if (access_check (temp, mode) == 0)
2435               {
2436                 if (pl->used_flag_ptr != 0)
2437                   *pl->used_flag_ptr = 1;
2438                 return temp;
2439               }
2440           }
2441
2442         /* Certain prefixes are tried with just the machine type,
2443            not the version.  This is used for finding as, ld, etc.  */
2444         if (just_machine_suffix && pl->require_machine_suffix == 2)
2445           {
2446             /* Some systems have a suffix for executable files.
2447                So try appending that first.  */
2448             if (file_suffix[0] != 0)
2449               {
2450                 strcpy (temp, pl->prefix);
2451                 strcat (temp, just_machine_suffix);
2452                 strcat (temp, multilib_name);
2453                 strcat (temp, file_suffix);
2454                 if (access_check (temp, mode) == 0)
2455                   {
2456                     if (pl->used_flag_ptr != 0)
2457                       *pl->used_flag_ptr = 1;
2458                     return temp;
2459                   }
2460               }
2461
2462             strcpy (temp, pl->prefix);
2463             strcat (temp, just_machine_suffix);
2464             strcat (temp, multilib_name);
2465             if (access_check (temp, mode) == 0)
2466               {
2467                 if (pl->used_flag_ptr != 0)
2468                   *pl->used_flag_ptr = 1;
2469                 return temp;
2470               }
2471           }
2472
2473         /* Certain prefixes can't be used without the machine suffix
2474            when the machine or version is explicitly specified.  */
2475         if (! pl->require_machine_suffix)
2476           {
2477             /* Some systems have a suffix for executable files.
2478                So try appending that first.  */
2479             if (file_suffix[0] != 0)
2480               {
2481                 strcpy (temp, pl->prefix);
2482                 strcat (temp, this_name);
2483                 strcat (temp, file_suffix);
2484                 if (access_check (temp, mode) == 0)
2485                   {
2486                     if (pl->used_flag_ptr != 0)
2487                       *pl->used_flag_ptr = 1;
2488                     return temp;
2489                   }
2490               }
2491
2492             strcpy (temp, pl->prefix);
2493             strcat (temp, this_name);
2494             if (access_check (temp, mode) == 0)
2495               {
2496                 if (pl->used_flag_ptr != 0)
2497                   *pl->used_flag_ptr = 1;
2498                 return temp;
2499               }
2500           }
2501       }
2502
2503   free (temp);
2504   return 0;
2505 }
2506
2507 /* Ranking of prefixes in the sort list. -B prefixes are put before
2508    all others.  */
2509
2510 enum path_prefix_priority
2511 {
2512   PREFIX_PRIORITY_B_OPT,
2513   PREFIX_PRIORITY_LAST
2514 };
2515
2516 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2517    order according to PRIORITY.  Within each PRIORITY, new entries are
2518    appended.
2519
2520    If WARN is nonzero, we will warn if no file is found
2521    through this prefix.  WARN should point to an int
2522    which will be set to 1 if this entry is used.
2523
2524    COMPONENT is the value to be passed to update_path.
2525
2526    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2527    the complete value of machine_suffix.
2528    2 means try both machine_suffix and just_machine_suffix.  */
2529
2530 static void
2531 add_prefix (struct path_prefix *pprefix, const char *prefix,
2532             const char *component, /* enum prefix_priority */ int priority,
2533             int require_machine_suffix, int *warn, int os_multilib)
2534 {
2535   struct prefix_list *pl, **prev;
2536   int len;
2537
2538   for (prev = &pprefix->plist;
2539        (*prev) != NULL && (*prev)->priority <= priority;
2540        prev = &(*prev)->next)
2541     ;
2542
2543   /* Keep track of the longest prefix.  */
2544
2545   prefix = update_path (prefix, component);
2546   len = strlen (prefix);
2547   if (len > pprefix->max_len)
2548     pprefix->max_len = len;
2549
2550   pl = xmalloc (sizeof (struct prefix_list));
2551   pl->prefix = prefix;
2552   pl->require_machine_suffix = require_machine_suffix;
2553   pl->used_flag_ptr = warn;
2554   pl->priority = priority;
2555   pl->os_multilib = os_multilib;
2556   if (warn)
2557     *warn = 0;
2558
2559   /* Insert after PREV.  */
2560   pl->next = (*prev);
2561   (*prev) = pl;
2562 }
2563
2564 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2565 static void
2566 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2567                       const char *component,
2568                       /* enum prefix_priority */ int priority,
2569                       int require_machine_suffix, int *warn, int os_multilib)
2570 {
2571   if (!IS_ABSOLUTE_PATH (prefix))
2572     abort ();
2573
2574   if (target_system_root)
2575     {
2576       if (target_sysroot_suffix)
2577           prefix = concat (target_sysroot_suffix, prefix, NULL);
2578       prefix = concat (target_system_root, prefix, NULL);
2579
2580       /* We have to override this because GCC's notion of sysroot
2581          moves along with GCC.  */
2582       component = "GCC";
2583     }
2584
2585   add_prefix (pprefix, prefix, component, priority,
2586               require_machine_suffix, warn, os_multilib);
2587 }
2588 \f
2589 /* Execute the command specified by the arguments on the current line of spec.
2590    When using pipes, this includes several piped-together commands
2591    with `|' between them.
2592
2593    Return 0 if successful, -1 if failed.  */
2594
2595 static int
2596 execute (void)
2597 {
2598   int i;
2599   int n_commands;               /* # of command.  */
2600   char *string;
2601   struct command
2602   {
2603     const char *prog;           /* program name.  */
2604     const char **argv;          /* vector of args.  */
2605     int pid;                    /* pid of process for this command.  */
2606   };
2607
2608   struct command *commands;     /* each command buffer with above info.  */
2609
2610   if (processing_spec_function)
2611     abort ();
2612
2613   /* Count # of piped commands.  */
2614   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2615     if (strcmp (argbuf[i], "|") == 0)
2616       n_commands++;
2617
2618   /* Get storage for each command.  */
2619   commands = alloca (n_commands * sizeof (struct command));
2620
2621   /* Split argbuf into its separate piped processes,
2622      and record info about each one.
2623      Also search for the programs that are to be run.  */
2624
2625   commands[0].prog = argbuf[0]; /* first command.  */
2626   commands[0].argv = &argbuf[0];
2627   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2628
2629   if (string)
2630     commands[0].argv[0] = string;
2631
2632   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2633     if (strcmp (argbuf[i], "|") == 0)
2634       {                         /* each command.  */
2635 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2636         fatal ("-pipe not supported");
2637 #endif
2638         argbuf[i] = 0;  /* termination of command args.  */
2639         commands[n_commands].prog = argbuf[i + 1];
2640         commands[n_commands].argv = &argbuf[i + 1];
2641         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2642                               X_OK, 0);
2643         if (string)
2644           commands[n_commands].argv[0] = string;
2645         n_commands++;
2646       }
2647
2648   argbuf[argbuf_index] = 0;
2649
2650   /* If -v, print what we are about to do, and maybe query.  */
2651
2652   if (verbose_flag)
2653     {
2654       /* For help listings, put a blank line between sub-processes.  */
2655       if (print_help_list)
2656         fputc ('\n', stderr);
2657
2658       /* Print each piped command as a separate line.  */
2659       for (i = 0; i < n_commands; i++)
2660         {
2661           const char *const *j;
2662
2663           if (verbose_only_flag)
2664             {
2665               for (j = commands[i].argv; *j; j++)
2666                 {
2667                   const char *p;
2668                   fprintf (stderr, " \"");
2669                   for (p = *j; *p; ++p)
2670                     {
2671                       if (*p == '"' || *p == '\\' || *p == '$')
2672                         fputc ('\\', stderr);
2673                       fputc (*p, stderr);
2674                     }
2675                   fputc ('"', stderr);
2676                 }
2677             }
2678           else
2679             for (j = commands[i].argv; *j; j++)
2680               fprintf (stderr, " %s", *j);
2681
2682           /* Print a pipe symbol after all but the last command.  */
2683           if (i + 1 != n_commands)
2684             fprintf (stderr, " |");
2685           fprintf (stderr, "\n");
2686         }
2687       fflush (stderr);
2688       if (verbose_only_flag != 0)
2689         {
2690           /* verbose_only_flag should act as if the spec was
2691              executed, so increment execution_count before
2692              returning.  This prevents spurious warnings about
2693              unused linker input files, etc.  */
2694           execution_count++;
2695           return 0;
2696         }
2697 #ifdef DEBUG
2698       notice ("\nGo ahead? (y or n) ");
2699       fflush (stderr);
2700       i = getchar ();
2701       if (i != '\n')
2702         while (getchar () != '\n')
2703           ;
2704
2705       if (i != 'y' && i != 'Y')
2706         return 0;
2707 #endif /* DEBUG */
2708     }
2709
2710 #ifdef ENABLE_VALGRIND_CHECKING
2711   /* Run the each command through valgrind.  To simplify prepending the
2712      path to valgrind and the option "-q" (for quiet operation unless
2713      something triggers), we allocate a separate argv array.  */
2714
2715   for (i = 0; i < n_commands; i++)
2716     {
2717       const char **argv;
2718       int argc;
2719       int j;
2720
2721       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2722         ;
2723
2724       argv = alloca ((argc + 3) * sizeof (char *));
2725
2726       argv[0] = VALGRIND_PATH;
2727       argv[1] = "-q";
2728       for (j = 2; j < argc + 2; j++)
2729         argv[j] = commands[i].argv[j - 2];
2730       argv[j] = NULL;
2731
2732       commands[i].argv = argv;
2733       commands[i].prog = argv[0];
2734     }
2735 #endif
2736
2737   /* Run each piped subprocess.  */
2738
2739   for (i = 0; i < n_commands; i++)
2740     {
2741       char *errmsg_fmt, *errmsg_arg;
2742       const char *string = commands[i].argv[0];
2743
2744       /* For some bizarre reason, the second argument of execvp() is
2745          char *const *, not const char *const *.  */
2746       commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2747                                   programname, temp_filename,
2748                                   &errmsg_fmt, &errmsg_arg,
2749                                   ((i == 0 ? PEXECUTE_FIRST : 0)
2750                                    | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2751                                    | (string == commands[i].prog
2752                                       ? PEXECUTE_SEARCH : 0)
2753                                    | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2754
2755       if (commands[i].pid == -1)
2756         pfatal_pexecute (errmsg_fmt, errmsg_arg);
2757
2758       if (string != commands[i].prog)
2759         free ((void *) string);
2760     }
2761
2762   execution_count++;
2763
2764   /* Wait for all the subprocesses to finish.
2765      We don't care what order they finish in;
2766      we know that N_COMMANDS waits will get them all.
2767      Ignore subprocesses that we don't know about,
2768      since they can be spawned by the process that exec'ed us.  */
2769
2770   {
2771     int ret_code = 0;
2772 #ifdef HAVE_GETRUSAGE
2773     struct timeval d;
2774     double ut = 0.0, st = 0.0;
2775 #endif
2776
2777     for (i = 0; i < n_commands;)
2778       {
2779         int j;
2780         int status;
2781         int pid;
2782
2783         pid = pwait (commands[i].pid, &status, 0);
2784         if (pid < 0)
2785           abort ();
2786
2787 #ifdef HAVE_GETRUSAGE
2788         if (report_times)
2789           {
2790             /* getrusage returns the total resource usage of all children
2791                up to now.  Copy the previous values into prus, get the
2792                current statistics, then take the difference.  */
2793
2794             prus = rus;
2795             getrusage (RUSAGE_CHILDREN, &rus);
2796             d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2797             d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2798             ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2799
2800             d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2801             d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2802             st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2803           }
2804 #endif
2805
2806         for (j = 0; j < n_commands; j++)
2807           if (commands[j].pid == pid)
2808             {
2809               i++;
2810               if (WIFSIGNALED (status))
2811                 {
2812 #ifdef SIGPIPE
2813                   /* SIGPIPE is a special case.  It happens in -pipe mode
2814                      when the compiler dies before the preprocessor is
2815                      done, or the assembler dies before the compiler is
2816                      done.  There's generally been an error already, and
2817                      this is just fallout.  So don't generate another error
2818                      unless we would otherwise have succeeded.  */
2819                   if (WTERMSIG (status) == SIGPIPE
2820                       && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2821                     ;
2822                   else
2823 #endif
2824                     fatal ("\
2825 Internal error: %s (program %s)\n\
2826 Please submit a full bug report.\n\
2827 See %s for instructions.",
2828                            strsignal (WTERMSIG (status)), commands[j].prog,
2829                            bug_report_url);
2830                   signal_count++;
2831                   ret_code = -1;
2832                 }
2833               else if (WIFEXITED (status)
2834                        && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2835                 {
2836                   if (WEXITSTATUS (status) > greatest_status)
2837                     greatest_status = WEXITSTATUS (status);
2838                   ret_code = -1;
2839                 }
2840 #ifdef HAVE_GETRUSAGE
2841               if (report_times && ut + st != 0)
2842                 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2843 #endif
2844               break;
2845             }
2846       }
2847     return ret_code;
2848   }
2849 }
2850 \f
2851 /* Find all the switches given to us
2852    and make a vector describing them.
2853    The elements of the vector are strings, one per switch given.
2854    If a switch uses following arguments, then the `part1' field
2855    is the switch itself and the `args' field
2856    is a null-terminated vector containing the following arguments.
2857    The `live_cond' field is:
2858    0 when initialized
2859    1 if the switch is true in a conditional spec,
2860    -1 if false (overridden by a later switch)
2861    -2 if this switch should be ignored (used in %<S)
2862    The `validated' field is nonzero if any spec has looked at this switch;
2863    if it remains zero at the end of the run, it must be meaningless.  */
2864
2865 #define SWITCH_OK       0
2866 #define SWITCH_FALSE   -1
2867 #define SWITCH_IGNORE  -2
2868 #define SWITCH_LIVE     1
2869
2870 struct switchstr
2871 {
2872   const char *part1;
2873   const char **args;
2874   int live_cond;
2875   unsigned char validated;
2876   unsigned char ordering;
2877 };
2878
2879 static struct switchstr *switches;
2880
2881 static int n_switches;
2882
2883 struct infile
2884 {
2885   const char *name;
2886   const char *language;
2887 };
2888
2889 /* Also a vector of input files specified.  */
2890
2891 static struct infile *infiles;
2892
2893 int n_infiles;
2894
2895 /* True if multiple input files are being compiled to a single
2896    assembly file.  */
2897
2898 static bool combine_inputs;
2899
2900 /* This counts the number of libraries added by lang_specific_driver, so that
2901    we can tell if there were any user supplied any files or libraries.  */
2902
2903 static int added_libraries;
2904
2905 /* And a vector of corresponding output files is made up later.  */
2906
2907 const char **outfiles;
2908
2909 /* Used to track if none of the -B paths are used.  */
2910 static int warn_B;
2911
2912 /* Gives value to pass as "warn" to add_prefix for standard prefixes.  */
2913 static int *warn_std_ptr = 0;
2914 \f
2915 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2916
2917 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2918    is true if we should look for an executable suffix.  DO_OBJ
2919    is true if we should look for an object suffix.  */
2920
2921 static const char *
2922 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2923                   int do_obj ATTRIBUTE_UNUSED)
2924 {
2925 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2926   int i;
2927 #endif
2928   int len;
2929
2930   if (name == NULL)
2931     return NULL;
2932
2933   len = strlen (name);
2934
2935 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2936   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2937   if (do_obj && len > 2
2938       && name[len - 2] == '.'
2939       && name[len - 1] == 'o')
2940     {
2941       obstack_grow (&obstack, name, len - 2);
2942       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2943       name = obstack_finish (&obstack);
2944     }
2945 #endif
2946
2947 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2948   /* If there is no filetype, make it the executable suffix (which includes
2949      the ".").  But don't get confused if we have just "-o".  */
2950   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2951     return name;
2952
2953   for (i = len - 1; i >= 0; i--)
2954     if (IS_DIR_SEPARATOR (name[i]))
2955       break;
2956
2957   for (i++; i < len; i++)
2958     if (name[i] == '.')
2959       return name;
2960
2961   obstack_grow (&obstack, name, len);
2962   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2963                  strlen (TARGET_EXECUTABLE_SUFFIX));
2964   name = obstack_finish (&obstack);
2965 #endif
2966
2967   return name;
2968 }
2969 #endif
2970 \f
2971 /* Display the command line switches accepted by gcc.  */
2972 static void
2973 display_help (void)
2974 {
2975   printf (_("Usage: %s [options] file...\n"), programname);
2976   fputs (_("Options:\n"), stdout);
2977
2978   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2979   fputs (_("  --help                   Display this information\n"), stdout);
2980   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2981   if (! verbose_flag)
2982     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2983   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2984   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2985   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2986   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2987   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2988   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2989   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2990   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2991   fputs (_("\
2992   -print-multi-lib         Display the mapping between command line options and\n\
2993                            multiple library search directories\n"), stdout);
2994   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2995   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2996   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2997   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2998   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2999   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3000   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3001   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3002   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3003   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3004   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3005   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3006   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3007   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3008   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3009   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3010   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3011   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3012   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3013   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3014   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3015   fputs (_("\
3016   -x <language>            Specify the language of the following input files\n\
3017                            Permissible languages include: c c++ assembler none\n\
3018                            'none' means revert to the default behavior of\n\
3019                            guessing the language based on the file's extension\n\
3020 "), stdout);
3021
3022   printf (_("\
3023 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3024  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3025  other options on to these processes the -W<letter> options must be used.\n\
3026 "), programname);
3027
3028   /* The rest of the options are displayed by invocations of the various
3029      sub-processes.  */
3030 }
3031
3032 static void
3033 add_preprocessor_option (const char *option, int len)
3034 {
3035   n_preprocessor_options++;
3036
3037   if (! preprocessor_options)
3038     preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3039   else
3040     preprocessor_options = xrealloc (preprocessor_options,
3041                                      n_preprocessor_options * sizeof (char *));
3042
3043   preprocessor_options [n_preprocessor_options - 1] =
3044     save_string (option, len);
3045 }
3046
3047 static void
3048 add_assembler_option (const char *option, int len)
3049 {
3050   n_assembler_options++;
3051
3052   if (! assembler_options)
3053     assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3054   else
3055     assembler_options = xrealloc (assembler_options,
3056                                   n_assembler_options * sizeof (char *));
3057
3058   assembler_options [n_assembler_options - 1] = save_string (option, len);
3059 }
3060
3061 static void
3062 add_linker_option (const char *option, int len)
3063 {
3064   n_linker_options++;
3065
3066   if (! linker_options)
3067     linker_options = xmalloc (n_linker_options * sizeof (char *));
3068   else
3069     linker_options = xrealloc (linker_options,
3070                                n_linker_options * sizeof (char *));
3071
3072   linker_options [n_linker_options - 1] = save_string (option, len);
3073 }
3074 \f
3075 /* Create the vector `switches' and its contents.
3076    Store its length in `n_switches'.  */
3077
3078 static void
3079 process_command (int argc, const char **argv)
3080 {
3081   int i;
3082   const char *temp;
3083   char *temp1;
3084   const char *spec_lang = 0;
3085   int last_language_n_infiles;
3086   int have_c = 0;
3087   int have_o = 0;
3088   int lang_n_infiles = 0;
3089 #ifdef MODIFY_TARGET_NAME
3090   int is_modify_target_name;
3091   int j;
3092 #endif
3093
3094   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3095
3096   n_switches = 0;
3097   n_infiles = 0;
3098   added_libraries = 0;
3099
3100   /* Figure compiler version from version string.  */
3101
3102   compiler_version = temp1 = xstrdup (version_string);
3103
3104   for (; *temp1; ++temp1)
3105     {
3106       if (*temp1 == ' ')
3107         {
3108           *temp1 = '\0';
3109           break;
3110         }
3111     }
3112
3113   /* If there is a -V or -b option (or both), process it now, before
3114      trying to interpret the rest of the command line.  */
3115   if (argc > 1 && argv[1][0] == '-'
3116       && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3117     {
3118       const char *new_version = DEFAULT_TARGET_VERSION;
3119       const char *new_machine = DEFAULT_TARGET_MACHINE;
3120       const char *progname = argv[0];
3121       char **new_argv;
3122       char *new_argv0;
3123       int baselen;
3124
3125       while (argc > 1 && argv[1][0] == '-'
3126              && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3127         {
3128           char opt = argv[1][1];
3129           const char *arg;
3130           if (argv[1][2] != '\0')
3131             {
3132               arg = argv[1] + 2;
3133               argc -= 1;
3134               argv += 1;
3135             }
3136           else if (argc > 2)
3137             {
3138               arg = argv[2];
3139               argc -= 2;
3140               argv += 2;
3141             }
3142           else
3143             fatal ("`-%c' option must have argument", opt);
3144           if (opt == 'V')
3145             new_version = arg;
3146           else
3147             new_machine = arg;
3148         }
3149
3150       for (baselen = strlen (progname); baselen > 0; baselen--)
3151         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3152           break;
3153       new_argv0 = xmemdup (progname, baselen,
3154                            baselen + concat_length (new_version, new_machine,
3155                                                     "-gcc-", NULL) + 1);
3156       strcpy (new_argv0 + baselen, new_machine);
3157       strcat (new_argv0, "-gcc-");
3158       strcat (new_argv0, new_version);
3159
3160       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3161                           (argc + 1) * sizeof (argv[0]));
3162       new_argv[0] = new_argv0;
3163
3164       execvp (new_argv0, new_argv);
3165       fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
3166     }
3167
3168   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3169      see if we can create it from the pathname specified in argv[0].  */
3170
3171   gcc_libexec_prefix = standard_libexec_prefix;
3172 #ifndef VMS
3173   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3174   if (!gcc_exec_prefix)
3175     {
3176       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3177                                               standard_exec_prefix);
3178       gcc_libexec_prefix = make_relative_prefix (argv[0],
3179                                                  standard_bindir_prefix,
3180                                                  standard_libexec_prefix);
3181       if (gcc_exec_prefix)
3182         putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3183     }
3184   else
3185     gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3186                                                standard_exec_prefix,
3187                                                standard_libexec_prefix);
3188 #else
3189 #endif
3190
3191   if (gcc_exec_prefix)
3192     {
3193       int len = strlen (gcc_exec_prefix);
3194
3195       if (len > (int) sizeof ("/lib/gcc/") - 1
3196           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3197         {
3198           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3199           if (IS_DIR_SEPARATOR (*temp)
3200               && strncmp (temp + 1, "lib", 3) == 0
3201               && IS_DIR_SEPARATOR (temp[4])
3202               && strncmp (temp + 5, "gcc", 3) == 0)
3203             len -= sizeof ("/lib/gcc/") - 1;
3204         }
3205
3206       set_std_prefix (gcc_exec_prefix, len);
3207       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3208                   PREFIX_PRIORITY_LAST, 0, NULL, 0);
3209       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3210                   PREFIX_PRIORITY_LAST, 0, NULL, 0);
3211     }
3212
3213   /* COMPILER_PATH and LIBRARY_PATH have values
3214      that are lists of directory names with colons.  */
3215
3216   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3217   if (temp)
3218     {
3219       const char *startp, *endp;
3220       char *nstore = alloca (strlen (temp) + 3);
3221
3222       startp = endp = temp;
3223       while (1)
3224         {
3225           if (*endp == PATH_SEPARATOR || *endp == 0)
3226             {
3227               strncpy (nstore, startp, endp - startp);
3228               if (endp == startp)
3229                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3230               else if (!IS_DIR_SEPARATOR (endp[-1]))
3231                 {
3232                   nstore[endp - startp] = DIR_SEPARATOR;
3233                   nstore[endp - startp + 1] = 0;
3234                 }
3235               else
3236                 nstore[endp - startp] = 0;
3237               add_prefix (&exec_prefixes, nstore, 0,
3238                           PREFIX_PRIORITY_LAST, 0, NULL, 0);
3239               add_prefix (&include_prefixes,
3240                           concat (nstore, "include", NULL),
3241                           0, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3242               if (*endp == 0)
3243                 break;
3244               endp = startp = endp + 1;
3245             }
3246           else
3247             endp++;
3248         }
3249     }
3250
3251   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3252   if (temp && *cross_compile == '0')
3253     {
3254       const char *startp, *endp;
3255       char *nstore = alloca (strlen (temp) + 3);
3256
3257       startp = endp = temp;
3258       while (1)
3259         {
3260           if (*endp == PATH_SEPARATOR || *endp == 0)
3261             {
3262               strncpy (nstore, startp, endp - startp);
3263               if (endp == startp)
3264                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3265               else if (!IS_DIR_SEPARATOR (endp[-1]))
3266                 {
3267                   nstore[endp - startp] = DIR_SEPARATOR;
3268                   nstore[endp - startp + 1] = 0;
3269                 }
3270               else
3271                 nstore[endp - startp] = 0;
3272               add_prefix (&startfile_prefixes, nstore, NULL,
3273                           PREFIX_PRIORITY_LAST, 0, NULL, 1);
3274               if (*endp == 0)
3275                 break;
3276               endp = startp = endp + 1;
3277             }
3278           else
3279             endp++;
3280         }
3281     }
3282
3283   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3284   GET_ENVIRONMENT (temp, "LPATH");
3285   if (temp && *cross_compile == '0')
3286     {
3287       const char *startp, *endp;
3288       char *nstore = alloca (strlen (temp) + 3);
3289
3290       startp = endp = temp;
3291       while (1)
3292         {
3293           if (*endp == PATH_SEPARATOR || *endp == 0)
3294             {
3295               strncpy (nstore, startp, endp - startp);
3296               if (endp == startp)
3297                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3298               else if (!IS_DIR_SEPARATOR (endp[-1]))
3299                 {
3300                   nstore[endp - startp] = DIR_SEPARATOR;
3301                   nstore[endp - startp + 1] = 0;
3302                 }
3303               else
3304                 nstore[endp - startp] = 0;
3305               add_prefix (&startfile_prefixes, nstore, NULL,
3306                           PREFIX_PRIORITY_LAST, 0, NULL, 1);
3307               if (*endp == 0)
3308                 break;
3309               endp = startp = endp + 1;
3310             }
3311           else
3312             endp++;
3313         }
3314     }
3315
3316   /* Convert new-style -- options to old-style.  */
3317   translate_options (&argc, (const char *const **) &argv);
3318
3319   /* Do language-specific adjustment/addition of flags.  */
3320   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3321
3322   /* Scan argv twice.  Here, the first time, just count how many switches
3323      there will be in their vector, and how many input files in theirs.
3324      Here we also parse the switches that cc itself uses (e.g. -v).  */
3325
3326   for (i = 1; i < argc; i++)
3327     {
3328       if (! strcmp (argv[i], "-dumpspecs"))
3329         {
3330           struct spec_list *sl;
3331           init_spec ();
3332           for (sl = specs; sl; sl = sl->next)
3333             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3334           if (link_command_spec)
3335             printf ("*link_command:\n%s\n\n", link_command_spec);
3336           exit (0);
3337         }
3338       else if (! strcmp (argv[i], "-dumpversion"))
3339         {
3340           printf ("%s\n", spec_version);
3341           exit (0);
3342         }
3343       else if (! strcmp (argv[i], "-dumpmachine"))
3344         {
3345           printf ("%s\n", spec_machine);
3346           exit (0);
3347         }
3348       else if (strcmp (argv[i], "-fversion") == 0)
3349         {
3350           /* translate_options () has turned --version into -fversion.  */
3351           printf (_("%s (GCC) %s\n"), programname, version_string);
3352           printf ("Copyright %s 2004 Free Software Foundation, Inc.\n",
3353                   _("(C)"));
3354           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3355 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3356                  stdout);
3357           exit (0);
3358         }
3359       else if (strcmp (argv[i], "-fhelp") == 0)
3360         {
3361           /* translate_options () has turned --help into -fhelp.  */
3362           print_help_list = 1;
3363
3364           /* We will be passing a dummy file on to the sub-processes.  */
3365           n_infiles++;
3366           n_switches++;
3367
3368           /* CPP driver cannot obtain switch from cc1_options.  */
3369           if (is_cpp_driver)
3370             add_preprocessor_option ("--help", 6);
3371           add_assembler_option ("--help", 6);
3372           add_linker_option ("--help", 6);
3373         }
3374       else if (strcmp (argv[i], "-ftarget-help") == 0)
3375         {
3376           /* translate_options() has turned --target-help into -ftarget-help.  */
3377           target_help_flag = 1;
3378
3379           /* We will be passing a dummy file on to the sub-processes.  */
3380           n_infiles++;
3381           n_switches++;
3382
3383           /* CPP driver cannot obtain switch from cc1_options.  */
3384           if (is_cpp_driver)
3385             add_preprocessor_option ("--target-help", 13);
3386           add_assembler_option ("--target-help", 13);
3387           add_linker_option ("--target-help", 13);
3388         }
3389       else if (! strcmp (argv[i], "-pass-exit-codes"))
3390         {
3391           pass_exit_codes = 1;
3392           n_switches++;
3393         }
3394       else if (! strcmp (argv[i], "-print-search-dirs"))
3395         print_search_dirs = 1;
3396       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3397         print_file_name = "libgcc.a";
3398       else if (! strncmp (argv[i], "-print-file-name=", 17))
3399         print_file_name = argv[i] + 17;
3400       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3401         print_prog_name = argv[i] + 17;
3402       else if (! strcmp (argv[i], "-print-multi-lib"))
3403         print_multi_lib = 1;
3404       else if (! strcmp (argv[i], "-print-multi-directory"))
3405         print_multi_directory = 1;
3406       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3407         print_multi_os_directory = 1;
3408       else if (! strncmp (argv[i], "-Wa,", 4))
3409         {
3410           int prev, j;
3411           /* Pass the rest of this option to the assembler.  */
3412
3413           /* Split the argument at commas.  */
3414           prev = 4;
3415           for (j = 4; argv[i][j]; j++)
3416             if (argv[i][j] == ',')
3417               {
3418                 add_assembler_option (argv[i] + prev, j - prev);
3419                 prev = j + 1;
3420               }
3421
3422           /* Record the part after the last comma.  */
3423           add_assembler_option (argv[i] + prev, j - prev);
3424         }
3425       else if (! strncmp (argv[i], "-Wp,", 4))
3426         {
3427           int prev, j;
3428           /* Pass the rest of this option to the preprocessor.  */
3429
3430           /* Split the argument at commas.  */
3431           prev = 4;
3432           for (j = 4; argv[i][j]; j++)
3433             if (argv[i][j] == ',')
3434               {
3435                 add_preprocessor_option (argv[i] + prev, j - prev);
3436                 prev = j + 1;
3437               }
3438
3439           /* Record the part after the last comma.  */
3440           add_preprocessor_option (argv[i] + prev, j - prev);
3441         }
3442       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3443         /* The +e options to the C++ front-end.  */
3444         n_switches++;
3445       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3446         {
3447           int j;
3448           /* Split the argument at commas.  */
3449           for (j = 3; argv[i][j]; j++)
3450             n_infiles += (argv[i][j] == ',');
3451         }
3452       else if (strcmp (argv[i], "-Xlinker") == 0)
3453         {
3454           if (i + 1 == argc)
3455             fatal ("argument to `-Xlinker' is missing");
3456
3457           n_infiles++;
3458           i++;
3459         }
3460       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3461         {
3462           if (i + 1 == argc)
3463             fatal ("argument to `-Xpreprocessor' is missing");
3464
3465           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3466         }
3467       else if (strcmp (argv[i], "-Xassembler") == 0)
3468         {
3469           if (i + 1 == argc)
3470             fatal ("argument to `-Xassembler' is missing");
3471
3472           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3473         }
3474       else if (strcmp (argv[i], "-l") == 0)
3475         {
3476           if (i + 1 == argc)
3477             fatal ("argument to `-l' is missing");
3478
3479           n_infiles++;
3480           i++;
3481         }
3482       else if (strncmp (argv[i], "-l", 2) == 0)
3483         n_infiles++;
3484       else if (strcmp (argv[i], "-save-temps") == 0)
3485         {
3486           save_temps_flag = 1;
3487           n_switches++;
3488         }
3489       else if (strcmp (argv[i], "-specs") == 0)
3490         {
3491           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3492           if (++i >= argc)
3493             fatal ("argument to `-specs' is missing");
3494
3495           user->next = (struct user_specs *) 0;
3496           user->filename = argv[i];
3497           if (user_specs_tail)
3498             user_specs_tail->next = user;
3499           else
3500             user_specs_head = user;
3501           user_specs_tail = user;
3502         }
3503       else if (strncmp (argv[i], "-specs=", 7) == 0)
3504         {
3505           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3506           if (strlen (argv[i]) == 7)
3507             fatal ("argument to `-specs=' is missing");
3508
3509           user->next = (struct user_specs *) 0;
3510           user->filename = argv[i] + 7;
3511           if (user_specs_tail)
3512             user_specs_tail->next = user;
3513           else
3514             user_specs_head = user;
3515           user_specs_tail = user;
3516         }
3517       else if (strcmp (argv[i], "-time") == 0)
3518         report_times = 1;
3519       else if (strcmp (argv[i], "-pipe") == 0)
3520         {
3521           /* -pipe has to go into the switches array as well as
3522              setting a flag.  */
3523           use_pipes = 1;
3524           n_switches++;
3525         }
3526       else if (strcmp (argv[i], "-###") == 0)
3527         {
3528           /* This is similar to -v except that there is no execution
3529              of the commands and the echoed arguments are quoted.  It