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