gcc/gcc.c

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