gcc/gcc.c

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