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