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