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    {"--pass-exit-codes", "-pass-exit-codes", 0},
1098    {"--pedantic", "-pedantic", 0},
1099    {"--pedantic-errors", "-pedantic-errors", 0},
1100    {"--pie", "-pie", 0},
1101    {"--pipe", "-pipe", 0},
1102    {"--prefix", "-B", "a"},
1103    {"--preprocess", "-E", 0},
1104    {"--print-search-dirs", "-print-search-dirs", 0},
1105    {"--print-file-name", "-print-file-name=", "aj"},
1106    {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1107    {"--print-missing-file-dependencies", "-MG", 0},
1108    {"--print-multi-lib", "-print-multi-lib", 0},
1109    {"--print-multi-directory", "-print-multi-directory", 0},
1110    {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1111    {"--print-prog-name", "-print-prog-name=", "aj"},
1112    {"--profile", "-p", 0},
1113    {"--profile-blocks", "-a", 0},
1114    {"--quiet", "-q", 0},
1115    {"--resource", "-fcompile-resource=", "aj"},
1116    {"--save-temps", "-save-temps", 0},
1117    {"--shared", "-shared", 0},
1118    {"--silent", "-q", 0},
1119    {"--specs", "-specs=", "aj"},
1120    {"--static", "-static", 0},
1121    {"--std", "-std=", "aj"},
1122    {"--symbolic", "-symbolic", 0},
1123    {"--time", "-time", 0},
1124    {"--trace-includes", "-H", 0},
1125    {"--traditional", "-traditional", 0},
1126    {"--traditional-cpp", "-traditional-cpp", 0},
1127    {"--trigraphs", "-trigraphs", 0},
1128    {"--undefine-macro", "-U", "aj"},
1129    {"--user-dependencies", "-MM", 0},
1130    {"--verbose", "-v", 0},
1131    {"--warn-", "-W", "*j"},
1132    {"--write-dependencies", "-MD", 0},
1133    {"--write-user-dependencies", "-MMD", 0},
1134    {"--", "-f", "*j"}
1135  };
1136 \f
1137
1138 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1139 static const struct {
1140   const char *const option_found;
1141   const char *const replacements;
1142 } target_option_translations[] =
1143 {
1144   TARGET_OPTION_TRANSLATE_TABLE,
1145   { 0, 0 }
1146 };
1147 #endif
1148
1149 /* Translate the options described by *ARGCP and *ARGVP.
1150    Make a new vector and store it back in *ARGVP,
1151    and store its length in *ARGVC.  */
1152
1153 static void
1154 translate_options (int *argcp, const char *const **argvp)
1155 {
1156   int i;
1157   int argc = *argcp;
1158   const char *const *argv = *argvp;
1159   int newvsize = (argc + 2) * 2 * sizeof (const char *);
1160   const char **newv = xmalloc (newvsize);
1161   int newindex = 0;
1162
1163   i = 0;
1164   newv[newindex++] = argv[i++];
1165
1166   while (i < argc)
1167     {
1168 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1169       int tott_idx;
1170
1171       for (tott_idx = 0;
1172            target_option_translations[tott_idx].option_found;
1173            tott_idx++)
1174         {
1175           if (strcmp (target_option_translations[tott_idx].option_found,
1176                       argv[i]) == 0)
1177             {
1178               int spaces = 1;
1179               const char *sp;
1180               char *np;
1181
1182               for (sp = target_option_translations[tott_idx].replacements;
1183                    *sp; sp++)
1184                 {
1185                   if (*sp == ' ')
1186                     spaces ++;
1187                 }
1188
1189               newvsize += spaces * sizeof (const char *);
1190               newv =  xrealloc (newv, newvsize);
1191
1192               sp = target_option_translations[tott_idx].replacements;
1193               np = xstrdup (sp);
1194
1195               while (1)
1196                 {
1197                   while (*np == ' ')
1198                     np++;
1199                   if (*np == 0)
1200                     break;
1201                   newv[newindex++] = np;
1202                   while (*np != ' ' && *np)
1203                     np++;
1204                   if (*np == 0)
1205                     break;
1206                   *np++ = 0;
1207                 }
1208
1209               i ++;
1210               break;
1211             }
1212         }
1213       if (target_option_translations[tott_idx].option_found)
1214         continue;
1215 #endif
1216
1217       /* Translate -- options.  */
1218       if (argv[i][0] == '-' && argv[i][1] == '-')
1219         {
1220           size_t j;
1221           /* Find a mapping that applies to this option.  */
1222           for (j = 0; j < ARRAY_SIZE (option_map); j++)
1223             {
1224               size_t optlen = strlen (option_map[j].name);
1225               size_t arglen = strlen (argv[i]);
1226               size_t complen = arglen > optlen ? optlen : arglen;
1227               const char *arginfo = option_map[j].arg_info;
1228
1229               if (arginfo == 0)
1230                 arginfo = "";
1231
1232               if (!strncmp (argv[i], option_map[j].name, complen))
1233                 {
1234                   const char *arg = 0;
1235
1236                   if (arglen < optlen)
1237                     {
1238                       size_t k;
1239                       for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1240                         if (strlen (option_map[k].name) >= arglen
1241                             && !strncmp (argv[i], option_map[k].name, arglen))
1242                           {
1243                             error ("ambiguous abbreviation %s", argv[i]);
1244                             break;
1245                           }
1246
1247                       if (k != ARRAY_SIZE (option_map))
1248                         break;
1249                     }
1250
1251                   if (arglen > optlen)
1252                     {
1253                       /* If the option has an argument, accept that.  */
1254                       if (argv[i][optlen] == '=')
1255                         arg = argv[i] + optlen + 1;
1256
1257                       /* If this mapping requires extra text at end of name,
1258                          accept that as "argument".  */
1259                       else if (strchr (arginfo, '*') != 0)
1260                         arg = argv[i] + optlen;
1261
1262                       /* Otherwise, extra text at end means mismatch.
1263                          Try other mappings.  */
1264                       else
1265                         continue;
1266                     }
1267
1268                   else if (strchr (arginfo, '*') != 0)
1269                     {
1270                       error ("incomplete '%s' option", option_map[j].name);
1271                       break;
1272                     }
1273
1274                   /* Handle arguments.  */
1275                   if (strchr (arginfo, 'a') != 0)
1276                     {
1277                       if (arg == 0)
1278                         {
1279                           if (i + 1 == argc)
1280                             {
1281                               error ("missing argument to '%s' option",
1282                                      option_map[j].name);
1283                               break;
1284                             }
1285
1286                           arg = argv[++i];
1287                         }
1288                     }
1289                   else if (strchr (arginfo, '*') != 0)
1290                     ;
1291                   else if (strchr (arginfo, 'o') == 0)
1292                     {
1293                       if (arg != 0)
1294                         error ("extraneous argument to '%s' option",
1295                                option_map[j].name);
1296                       arg = 0;
1297                     }
1298
1299                   /* Store the translation as one argv elt or as two.  */
1300                   if (arg != 0 && strchr (arginfo, 'j') != 0)
1301                     newv[newindex++] = concat (option_map[j].equivalent, arg,
1302                                                NULL);
1303                   else if (arg != 0)
1304                     {
1305                       newv[newindex++] = option_map[j].equivalent;
1306                       newv[newindex++] = arg;
1307                     }
1308                   else
1309                     newv[newindex++] = option_map[j].equivalent;
1310
1311                   break;
1312                 }
1313             }
1314           i++;
1315         }
1316
1317       /* Handle old-fashioned options--just copy them through,
1318          with their arguments.  */
1319       else if (argv[i][0] == '-')
1320         {
1321           const char *p = argv[i] + 1;
1322           int c = *p;
1323           int nskip = 1;
1324
1325           if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1326             nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1327           else if (WORD_SWITCH_TAKES_ARG (p))
1328             nskip += WORD_SWITCH_TAKES_ARG (p);
1329           else if ((c == 'B' || c == 'b' || c == 'x')
1330                    && p[1] == 0)
1331             nskip += 1;
1332           else if (! strcmp (p, "Xlinker"))
1333             nskip += 1;
1334           else if (! strcmp (p, "Xpreprocessor"))
1335             nskip += 1;
1336           else if (! strcmp (p, "Xassembler"))
1337             nskip += 1;
1338
1339           /* Watch out for an option at the end of the command line that
1340              is missing arguments, and avoid skipping past the end of the
1341              command line.  */
1342           if (nskip + i > argc)
1343             nskip = argc - i;
1344
1345           while (nskip > 0)
1346             {
1347               newv[newindex++] = argv[i++];
1348               nskip--;
1349             }
1350         }
1351       else
1352         /* Ordinary operands, or +e options.  */
1353         newv[newindex++] = argv[i++];
1354     }
1355
1356   newv[newindex] = 0;
1357
1358   *argvp = newv;
1359   *argcp = newindex;
1360 }
1361 \f
1362 static char *
1363 skip_whitespace (char *p)
1364 {
1365   while (1)
1366     {
1367       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1368          be considered whitespace.  */
1369       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1370         return p + 1;
1371       else if (*p == '\n' || *p == ' ' || *p == '\t')
1372         p++;
1373       else if (*p == '#')
1374         {
1375           while (*p != '\n')
1376             p++;
1377           p++;
1378         }
1379       else
1380         break;
1381     }
1382
1383   return p;
1384 }
1385 /* Structures to keep track of prefixes to try when looking for files.  */
1386
1387 struct prefix_list
1388 {
1389   const char *prefix;         /* String to prepend to the path.  */
1390   struct prefix_list *next;   /* Next in linked list.  */
1391   int require_machine_suffix; /* Don't use without machine_suffix.  */
1392   /* 2 means try both machine_suffix and just_machine_suffix.  */
1393   int priority;               /* Sort key - priority within list.  */
1394   int os_multilib;            /* 1 if OS multilib scheme should be used,
1395                                  0 for GCC multilib scheme.  */
1396 };
1397
1398 struct path_prefix
1399 {
1400   struct prefix_list *plist;  /* List of prefixes to try */
1401   int max_len;                /* Max length of a prefix in PLIST */
1402   const char *name;           /* Name of this list (used in config stuff) */
1403 };
1404
1405 /* List of prefixes to try when looking for executables.  */
1406
1407 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1408
1409 /* List of prefixes to try when looking for startup (crt0) files.  */
1410
1411 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1412
1413 /* List of prefixes to try when looking for include files.  */
1414
1415 static struct path_prefix include_prefixes = { 0, 0, "include" };
1416
1417 /* Suffix to attach to directories searched for commands.
1418    This looks like `MACHINE/VERSION/'.  */
1419
1420 static const char *machine_suffix = 0;
1421
1422 /* Suffix to attach to directories searched for commands.
1423    This is just `MACHINE/'.  */
1424
1425 static const char *just_machine_suffix = 0;
1426
1427 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1428
1429 static const char *gcc_exec_prefix;
1430
1431 /* Adjusted value of standard_libexec_prefix.  */
1432
1433 static const char *gcc_libexec_prefix;
1434
1435 /* Default prefixes to attach to command names.  */
1436
1437 #ifndef STANDARD_STARTFILE_PREFIX_1
1438 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1439 #endif
1440 #ifndef STANDARD_STARTFILE_PREFIX_2
1441 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1442 #endif
1443
1444 #ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
1445 #undef MD_EXEC_PREFIX
1446 #undef MD_STARTFILE_PREFIX
1447 #undef MD_STARTFILE_PREFIX_1
1448 #endif
1449
1450 /* If no prefixes defined, use the null string, which will disable them.  */
1451 #ifndef MD_EXEC_PREFIX
1452 #define MD_EXEC_PREFIX ""
1453 #endif
1454 #ifndef MD_STARTFILE_PREFIX
1455 #define MD_STARTFILE_PREFIX ""
1456 #endif
1457 #ifndef MD_STARTFILE_PREFIX_1
1458 #define MD_STARTFILE_PREFIX_1 ""
1459 #endif
1460
1461 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1462 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1463 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
1464 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1465
1466 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1467 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1468 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1469 static const char *const standard_startfile_prefix_1
1470   = STANDARD_STARTFILE_PREFIX_1;
1471 static const char *const standard_startfile_prefix_2
1472   = STANDARD_STARTFILE_PREFIX_2;
1473
1474 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1475 static const char *tooldir_prefix;
1476
1477 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1478
1479 static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1480
1481 /* Subdirectory to use for locating libraries.  Set by
1482    set_multilib_dir based on the compilation options.  */
1483
1484 static const char *multilib_dir;
1485
1486 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1487    set_multilib_dir based on the compilation options.  */
1488
1489 static const char *multilib_os_dir;
1490 \f
1491 /* Structure to keep track of the specs that have been defined so far.
1492    These are accessed using %(specname) or %[specname] in a compiler
1493    or link spec.  */
1494
1495 struct spec_list
1496 {
1497                                 /* The following 2 fields must be first */
1498                                 /* to allow EXTRA_SPECS to be initialized */
1499   const char *name;             /* name of the spec.  */
1500   const char *ptr;              /* available ptr if no static pointer */
1501
1502                                 /* The following fields are not initialized */
1503                                 /* by EXTRA_SPECS */
1504   const char **ptr_spec;        /* pointer to the spec itself.  */
1505   struct spec_list *next;       /* Next spec in linked list.  */
1506   int name_len;                 /* length of the name */
1507   int alloc_p;                  /* whether string was allocated */
1508 };
1509
1510 #define INIT_STATIC_SPEC(NAME,PTR) \
1511 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1512
1513 /* List of statically defined specs.  */
1514 static struct spec_list static_specs[] =
1515 {
1516   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1517   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1518   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1519   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1520   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1521   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1522   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1523   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1524   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1525   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1526   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1527   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1528   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1529   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1530   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1531   INIT_STATIC_SPEC ("link",                     &link_spec),
1532   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1533   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1534   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1535   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1536   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1537   INIT_STATIC_SPEC ("switches_need_spaces",     &switches_need_spaces),
1538   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1539   INIT_STATIC_SPEC ("version",                  &compiler_version),
1540   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1541   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1542   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1543   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1544   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1545   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1546   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1547   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1548   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1549   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1550   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1551   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1552   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1553   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1554 };
1555
1556 #ifdef EXTRA_SPECS              /* additional specs needed */
1557 /* Structure to keep track of just the first two args of a spec_list.
1558    That is all that the EXTRA_SPECS macro gives us.  */
1559 struct spec_list_1
1560 {
1561   const char *const name;
1562   const char *const ptr;
1563 };
1564
1565 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1566 static struct spec_list *extra_specs = (struct spec_list *) 0;
1567 #endif
1568
1569 /* List of dynamically allocates specs that have been defined so far.  */
1570
1571 static struct spec_list *specs = (struct spec_list *) 0;
1572 \f
1573 /* List of static spec functions.  */
1574
1575 static const struct spec_function static_spec_functions[] =
1576 {
1577   { "if-exists",                if_exists_spec_function },
1578   { "if-exists-else",           if_exists_else_spec_function },
1579   { "replace-outfile",          replace_outfile_spec_function },
1580   { 0, 0 }
1581 };
1582
1583 static int processing_spec_function;
1584 \f
1585 /* Add appropriate libgcc specs to OBSTACK, taking into account
1586    various permutations of -shared-libgcc, -shared, and such.  */
1587
1588 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1589
1590 #ifndef USE_LD_AS_NEEDED
1591 #define USE_LD_AS_NEEDED 0
1592 #endif
1593
1594 static void
1595 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1596                 const char *static_name, const char *eh_name)
1597 {
1598   char *buf;
1599
1600   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1601                 "}%{!static:%{!static-libgcc:",
1602 #if USE_LD_AS_NEEDED
1603                 "%{!shared-libgcc:", static_name,
1604                 " --as-needed ", shared_name, " --no-as-needed}"
1605                 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
1606                 "}",
1607 #else
1608                 "%{!shared:%{!shared-libgcc:", static_name, " ",
1609                 eh_name, "}%{shared-libgcc:", shared_name, " ",
1610                 static_name, "}}%{shared:",
1611 #ifdef LINK_EH_SPEC
1612                 "%{shared-libgcc:", shared_name,
1613                 "}%{!shared-libgcc:", static_name, "}",
1614 #else
1615                 shared_name,
1616 #endif
1617 #endif
1618                 "}}}", NULL);
1619
1620   obstack_grow (obstack, buf, strlen (buf));
1621   free (buf);
1622 }
1623 #endif /* ENABLE_SHARED_LIBGCC */
1624
1625 /* Initialize the specs lookup routines.  */
1626
1627 static void
1628 init_spec (void)
1629 {
1630   struct spec_list *next = (struct spec_list *) 0;
1631   struct spec_list *sl   = (struct spec_list *) 0;
1632   int i;
1633
1634   if (specs)
1635     return;                     /* Already initialized.  */
1636
1637   if (verbose_flag)
1638     notice ("Using built-in specs.\n");
1639
1640 #ifdef EXTRA_SPECS
1641   extra_specs = xcalloc (sizeof (struct spec_list),
1642                          ARRAY_SIZE (extra_specs_1));
1643
1644   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1645     {
1646       sl = &extra_specs[i];
1647       sl->name = extra_specs_1[i].name;
1648       sl->ptr = extra_specs_1[i].ptr;
1649       sl->next = next;
1650       sl->name_len = strlen (sl->name);
1651       sl->ptr_spec = &sl->ptr;
1652       next = sl;
1653     }
1654 #endif
1655
1656   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
1657      on ?: in file-scope variable initializations.  */
1658   asm_debug = ASM_DEBUG_SPEC;
1659
1660   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1661     {
1662       sl = &static_specs[i];
1663       sl->next = next;
1664       next = sl;
1665     }
1666
1667 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1668   /* ??? If neither -shared-libgcc nor --static-libgcc was
1669      seen, then we should be making an educated guess.  Some proposed
1670      heuristics for ELF include:
1671
1672         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1673             program will be doing dynamic loading, which will likely
1674             need the shared libgcc.
1675
1676         (2) If "-ldl", then it's also a fair bet that we're doing
1677             dynamic loading.
1678
1679         (3) For each ET_DYN we're linking against (either through -lfoo
1680             or /some/path/foo.so), check to see whether it or one of
1681             its dependencies depends on a shared libgcc.
1682
1683         (4) If "-shared"
1684
1685             If the runtime is fixed to look for program headers instead
1686             of calling __register_frame_info at all, for each object,
1687             use the shared libgcc if any EH symbol referenced.
1688
1689             If crtstuff is fixed to not invoke __register_frame_info
1690             automatically, for each object, use the shared libgcc if
1691             any non-empty unwind section found.
1692
1693      Doing any of this probably requires invoking an external program to
1694      do the actual object file scanning.  */
1695   {
1696     const char *p = libgcc_spec;
1697     int in_sep = 1;
1698
1699     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1700        when given the proper command line arguments.  */
1701     while (*p)
1702       {
1703         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1704           {
1705             init_gcc_specs (&obstack,
1706 #ifdef NO_SHARED_LIBGCC_MULTILIB
1707                             "-lgcc_s"
1708 #else
1709                             "-lgcc_s%M"
1710 #endif
1711 #ifdef USE_LIBUNWIND_EXCEPTIONS
1712                             " -lunwind"
1713 #endif
1714                             ,
1715                             "-lgcc",
1716                             "-lgcc_eh"
1717 #ifdef USE_LIBUNWIND_EXCEPTIONS
1718                             " -lunwind"
1719 #endif
1720                             );
1721
1722             p += 5;
1723             in_sep = 0;
1724           }
1725         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1726           {
1727             /* Ug.  We don't know shared library extensions.  Hope that
1728                systems that use this form don't do shared libraries.  */
1729             init_gcc_specs (&obstack,
1730 #ifdef NO_SHARED_LIBGCC_MULTILIB
1731                             "-lgcc_s"
1732 #else
1733                             "-lgcc_s%M"
1734 #endif
1735                             ,
1736                             "libgcc.a%s",
1737                             "libgcc_eh.a%s"
1738 #ifdef USE_LIBUNWIND_EXCEPTIONS
1739                             " -lunwind"
1740 #endif
1741                             );
1742             p += 10;
1743             in_sep = 0;
1744           }
1745         else
1746           {
1747             obstack_1grow (&obstack, *p);
1748             in_sep = (*p == ' ');
1749             p += 1;
1750           }
1751       }
1752
1753     obstack_1grow (&obstack, '\0');
1754     libgcc_spec = obstack_finish (&obstack);
1755   }
1756 #endif
1757 #ifdef USE_AS_TRADITIONAL_FORMAT
1758   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1759   {
1760     static const char tf[] = "--traditional-format ";
1761     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1762     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1763     asm_spec = obstack_finish (&obstack);
1764   }
1765 #endif
1766 #ifdef LINK_EH_SPEC
1767   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1768   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1769   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1770   link_spec = obstack_finish (&obstack);
1771 #endif
1772
1773   specs = sl;
1774 }
1775 \f
1776 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1777    removed; If the spec starts with a + then SPEC is added to the end of the
1778    current spec.  */
1779
1780 static void
1781 set_spec (const char *name, const char *spec)
1782 {
1783   struct spec_list *sl;
1784   const char *old_spec;
1785   int name_len = strlen (name);
1786   int i;
1787
1788   /* If this is the first call, initialize the statically allocated specs.  */
1789   if (!specs)
1790     {
1791       struct spec_list *next = (struct spec_list *) 0;
1792       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1793         {
1794           sl = &static_specs[i];
1795           sl->next = next;
1796           next = sl;
1797         }
1798       specs = sl;
1799     }
1800
1801   /* See if the spec already exists.  */
1802   for (sl = specs; sl; sl = sl->next)
1803     if (name_len == sl->name_len && !strcmp (sl->name, name))
1804       break;
1805
1806   if (!sl)
1807     {
1808       /* Not found - make it.  */
1809       sl = xmalloc (sizeof (struct spec_list));
1810       sl->name = xstrdup (name);
1811       sl->name_len = name_len;
1812       sl->ptr_spec = &sl->ptr;
1813       sl->alloc_p = 0;
1814       *(sl->ptr_spec) = "";
1815       sl->next = specs;
1816       specs = sl;
1817     }
1818
1819   old_spec = *(sl->ptr_spec);
1820   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1821                      ? concat (old_spec, spec + 1, NULL)
1822                      : xstrdup (spec));
1823
1824 #ifdef DEBUG_SPECS
1825   if (verbose_flag)
1826     notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1827 #endif
1828
1829   /* Free the old spec.  */
1830   if (old_spec && sl->alloc_p)
1831     free ((void *) old_spec);
1832
1833   sl->alloc_p = 1;
1834 }
1835 \f
1836 /* Accumulate a command (program name and args), and run it.  */
1837
1838 /* Vector of pointers to arguments in the current line of specifications.  */
1839
1840 static const char **argbuf;
1841
1842 /* Number of elements allocated in argbuf.  */
1843
1844 static int argbuf_length;
1845
1846 /* Number of elements in argbuf currently in use (containing args).  */
1847
1848 static int argbuf_index;
1849
1850 /* Position in the argbuf array containing the name of the output file
1851    (the value associated with the "-o" flag).  */
1852
1853 static int have_o_argbuf_index = 0;
1854
1855 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1856    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1857    it here.  */
1858
1859 static struct temp_name {
1860   const char *suffix;   /* suffix associated with the code.  */
1861   int length;           /* strlen (suffix).  */
1862   int unique;           /* Indicates whether %g or %u/%U was used.  */
1863   const char *filename; /* associated filename.  */
1864   int filename_length;  /* strlen (filename).  */
1865   struct temp_name *next;
1866 } *temp_names;
1867
1868 /* Number of commands executed so far.  */
1869
1870 static int execution_count;
1871
1872 /* Number of commands that exited with a signal.  */
1873
1874 static int signal_count;
1875
1876 /* Name with which this program was invoked.  */
1877
1878 static const char *programname;
1879 \f
1880 /* Allocate the argument vector.  */
1881
1882 static void
1883 alloc_args (void)
1884 {
1885   argbuf_length = 10;
1886   argbuf = xmalloc (argbuf_length * sizeof (const char *));
1887 }
1888
1889 /* Clear out the vector of arguments (after a command is executed).  */
1890
1891 static void
1892 clear_args (void)
1893 {
1894   argbuf_index = 0;
1895 }
1896
1897 /* Add one argument to the vector at the end.
1898    This is done when a space is seen or at the end of the line.
1899    If DELETE_ALWAYS is nonzero, the arg is a filename
1900     and the file should be deleted eventually.
1901    If DELETE_FAILURE is nonzero, the arg is a filename
1902     and the file should be deleted if this compilation fails.  */
1903
1904 static void
1905 store_arg (const char *arg, int delete_always, int delete_failure)
1906 {
1907   if (argbuf_index + 1 == argbuf_length)
1908     argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1909
1910   argbuf[argbuf_index++] = arg;
1911   argbuf[argbuf_index] = 0;
1912
1913   if (strcmp (arg, "-o") == 0)
1914     have_o_argbuf_index = argbuf_index;
1915   if (delete_always || delete_failure)
1916     record_temp_file (arg, delete_always, delete_failure);
1917 }
1918 \f
1919 /* Load specs from a file name named FILENAME, replacing occurrences of
1920    various different types of line-endings, \r\n, \n\r and just \r, with
1921    a single \n.  */
1922
1923 static char *
1924 load_specs (const char *filename)
1925 {
1926   int desc;
1927   int readlen;
1928   struct stat statbuf;
1929   char *buffer;
1930   char *buffer_p;
1931   char *specs;
1932   char *specs_p;
1933
1934   if (verbose_flag)
1935     notice ("Reading specs from %s\n", filename);
1936
1937   /* Open and stat the file.  */
1938   desc = open (filename, O_RDONLY, 0);
1939   if (desc < 0)
1940     pfatal_with_name (filename);
1941   if (stat (filename, &statbuf) < 0)
1942     pfatal_with_name (filename);
1943
1944   /* Read contents of file into BUFFER.  */
1945   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1946   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1947   if (readlen < 0)
1948     pfatal_with_name (filename);
1949   buffer[readlen] = 0;
1950   close (desc);
1951
1952   specs = xmalloc (readlen + 1);
1953   specs_p = specs;
1954   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1955     {
1956       int skip = 0;
1957       char c = *buffer_p;
1958       if (c == '\r')
1959         {
1960           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1961             skip = 1;
1962           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1963             skip = 1;
1964           else                                                  /* \r */
1965             c = '\n';
1966         }
1967       if (! skip)
1968         *specs_p++ = c;
1969     }
1970   *specs_p = '\0';
1971
1972   free (buffer);
1973   return (specs);
1974 }
1975
1976 /* Read compilation specs from a file named FILENAME,
1977    replacing the default ones.
1978
1979    A suffix which starts with `*' is a definition for
1980    one of the machine-specific sub-specs.  The "suffix" should be
1981    *asm, *cc1, *cpp, *link, *startfile, etc.
1982    The corresponding spec is stored in asm_spec, etc.,
1983    rather than in the `compilers' vector.
1984
1985    Anything invalid in the file is a fatal error.  */
1986
1987 static void
1988 read_specs (const char *filename, int main_p)
1989 {
1990   char *buffer;
1991   char *p;
1992
1993   buffer = load_specs (filename);
1994
1995   /* Scan BUFFER for specs, putting them in the vector.  */
1996   p = buffer;
1997   while (1)
1998     {
1999       char *suffix;
2000       char *spec;
2001       char *in, *out, *p1, *p2, *p3;
2002
2003       /* Advance P in BUFFER to the next nonblank nocomment line.  */
2004       p = skip_whitespace (p);
2005       if (*p == 0)
2006         break;
2007
2008       /* Is this a special command that starts with '%'? */
2009       /* Don't allow this for the main specs file, since it would
2010          encourage people to overwrite it.  */
2011       if (*p == '%' && !main_p)
2012         {
2013           p1 = p;
2014           while (*p && *p != '\n')
2015             p++;
2016
2017           /* Skip '\n'.  */
2018           p++;
2019
2020           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2021               && (p1[sizeof "%include" - 1] == ' '
2022                   || p1[sizeof "%include" - 1] == '\t'))
2023             {
2024               char *new_filename;
2025
2026               p1 += sizeof ("%include");
2027               while (*p1 == ' ' || *p1 == '\t')
2028                 p1++;
2029
2030               if (*p1++ != '<' || p[-2] != '>')
2031                 fatal ("specs %%include syntax malformed after %ld characters",
2032                        (long) (p1 - buffer + 1));
2033
2034               p[-2] = '\0';
2035               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2036               read_specs (new_filename ? new_filename : p1, FALSE);
2037               continue;
2038             }
2039           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2040                    && (p1[sizeof "%include_noerr" - 1] == ' '
2041                        || p1[sizeof "%include_noerr" - 1] == '\t'))
2042             {
2043               char *new_filename;
2044
2045               p1 += sizeof "%include_noerr";
2046               while (*p1 == ' ' || *p1 == '\t')
2047                 p1++;
2048
2049               if (*p1++ != '<' || p[-2] != '>')
2050                 fatal ("specs %%include syntax malformed after %ld characters",
2051                        (long) (p1 - buffer + 1));
2052
2053               p[-2] = '\0';
2054               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2055               if (new_filename)
2056                 read_specs (new_filename, FALSE);
2057               else if (verbose_flag)
2058                 notice ("could not find specs file %s\n", p1);
2059               continue;
2060             }
2061           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2062                    && (p1[sizeof "%rename" - 1] == ' '
2063                        || p1[sizeof "%rename" - 1] == '\t'))
2064             {
2065               int name_len;
2066               struct spec_list *sl;
2067               struct spec_list *newsl;
2068
2069               /* Get original name.  */
2070               p1 += sizeof "%rename";
2071               while (*p1 == ' ' || *p1 == '\t')
2072                 p1++;
2073
2074               if (! ISALPHA ((unsigned char) *p1))
2075                 fatal ("specs %%rename syntax malformed after %ld characters",
2076                        (long) (p1 - buffer));
2077
2078               p2 = p1;
2079               while (*p2 && !ISSPACE ((unsigned char) *p2))
2080                 p2++;
2081
2082               if (*p2 != ' ' && *p2 != '\t')
2083                 fatal ("specs %%rename syntax malformed after %ld characters",
2084                        (long) (p2 - buffer));
2085
2086               name_len = p2 - p1;
2087               *p2++ = '\0';
2088               while (*p2 == ' ' || *p2 == '\t')
2089                 p2++;
2090
2091               if (! ISALPHA ((unsigned char) *p2))
2092                 fatal ("specs %%rename syntax malformed after %ld characters",
2093                        (long) (p2 - buffer));
2094
2095               /* Get new spec name.  */
2096               p3 = p2;
2097               while (*p3 && !ISSPACE ((unsigned char) *p3))
2098                 p3++;
2099
2100               if (p3 != p - 1)
2101                 fatal ("specs %%rename syntax malformed after %ld characters",
2102                        (long) (p3 - buffer));
2103               *p3 = '\0';
2104
2105               for (sl = specs; sl; sl = sl->next)
2106                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2107                   break;
2108
2109               if (!sl)
2110                 fatal ("specs %s spec was not found to be renamed", p1);
2111
2112               if (strcmp (p1, p2) == 0)
2113                 continue;
2114
2115               for (newsl = specs; newsl; newsl = newsl->next)
2116                 if (strcmp (newsl->name, p2) == 0)
2117                   fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2118                     filename, p1, p2);
2119
2120               if (verbose_flag)
2121                 {
2122                   notice ("rename spec %s to %s\n", p1, p2);
2123 #ifdef DEBUG_SPECS
2124                   notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2125 #endif
2126                 }
2127
2128               set_spec (p2, *(sl->ptr_spec));
2129               if (sl->alloc_p)
2130                 free ((void *) *(sl->ptr_spec));
2131
2132               *(sl->ptr_spec) = "";
2133               sl->alloc_p = 0;
2134               continue;
2135             }
2136           else
2137             fatal ("specs unknown %% command after %ld characters",
2138                    (long) (p1 - buffer));
2139         }
2140
2141       /* Find the colon that should end the suffix.  */
2142       p1 = p;
2143       while (*p1 && *p1 != ':' && *p1 != '\n')
2144         p1++;
2145
2146       /* The colon shouldn't be missing.  */
2147       if (*p1 != ':')
2148         fatal ("specs file malformed after %ld characters",
2149                (long) (p1 - buffer));
2150
2151       /* Skip back over trailing whitespace.  */
2152       p2 = p1;
2153       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2154         p2--;
2155
2156       /* Copy the suffix to a string.  */
2157       suffix = save_string (p, p2 - p);
2158       /* Find the next line.  */
2159       p = skip_whitespace (p1 + 1);
2160       if (p[1] == 0)
2161         fatal ("specs file malformed after %ld characters",
2162                (long) (p - buffer));
2163
2164       p1 = p;
2165       /* Find next blank line or end of string.  */
2166       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2167         p1++;
2168
2169       /* Specs end at the blank line and do not include the newline.  */
2170       spec = save_string (p, p1 - p);
2171       p = p1;
2172
2173       /* Delete backslash-newline sequences from the spec.  */
2174       in = spec;
2175       out = spec;
2176       while (*in != 0)
2177         {
2178           if (in[0] == '\\' && in[1] == '\n')
2179             in += 2;
2180           else if (in[0] == '#')
2181             while (*in && *in != '\n')
2182               in++;
2183
2184           else
2185             *out++ = *in++;
2186         }
2187       *out = 0;
2188
2189       if (suffix[0] == '*')
2190         {
2191           if (! strcmp (suffix, "*link_command"))
2192             link_command_spec = spec;
2193           else
2194             set_spec (suffix + 1, spec);
2195         }
2196       else
2197         {
2198           /* Add this pair to the vector.  */
2199           compilers
2200             = xrealloc (compilers,
2201                         (n_compilers + 2) * sizeof (struct compiler));
2202
2203           compilers[n_compilers].suffix = suffix;
2204           compilers[n_compilers].spec = spec;
2205           n_compilers++;
2206           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2207         }
2208
2209       if (*suffix == 0)
2210         link_command_spec = spec;
2211     }
2212
2213   if (link_command_spec == 0)
2214     fatal ("spec file has no spec for linking");
2215 }
2216 \f
2217 /* Record the names of temporary files we tell compilers to write,
2218    and delete them at the end of the run.  */
2219
2220 /* This is the common prefix we use to make temp file names.
2221    It is chosen once for each run of this program.
2222    It is substituted into a spec by %g or %j.
2223    Thus, all temp file names contain this prefix.
2224    In practice, all temp file names start with this prefix.
2225
2226    This prefix comes from the envvar TMPDIR if it is defined;
2227    otherwise, from the P_tmpdir macro if that is defined;
2228    otherwise, in /usr/tmp or /tmp;
2229    or finally the current directory if all else fails.  */
2230
2231 static const char *temp_filename;
2232
2233 /* Length of the prefix.  */
2234
2235 static int temp_filename_length;
2236
2237 /* Define the list of temporary files to delete.  */
2238
2239 struct temp_file
2240 {
2241   const char *name;
2242   struct temp_file *next;
2243 };
2244
2245 /* Queue of files to delete on success or failure of compilation.  */
2246 static struct temp_file *always_delete_queue;
2247 /* Queue of files to delete on failure of compilation.  */
2248 static struct temp_file *failure_delete_queue;
2249
2250 /* Record FILENAME as a file to be deleted automatically.
2251    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2252    otherwise delete it in any case.
2253    FAIL_DELETE nonzero means delete it if a compilation step fails;
2254    otherwise delete it in any case.  */
2255
2256 void
2257 record_temp_file (const char *filename, int always_delete, int fail_delete)
2258 {
2259   char *const name = xstrdup (filename);
2260
2261   if (always_delete)
2262     {
2263       struct temp_file *temp;
2264       for (temp = always_delete_queue; temp; temp = temp->next)
2265         if (! strcmp (name, temp->name))
2266           goto already1;
2267
2268       temp = xmalloc (sizeof (struct temp_file));
2269       temp->next = always_delete_queue;
2270       temp->name = name;
2271       always_delete_queue = temp;
2272
2273     already1:;
2274     }
2275
2276   if (fail_delete)
2277     {
2278       struct temp_file *temp;
2279       for (temp = failure_delete_queue; temp; temp = temp->next)
2280         if (! strcmp (name, temp->name))
2281           goto already2;
2282
2283       temp = xmalloc (sizeof (struct temp_file));
2284       temp->next = failure_delete_queue;
2285       temp->name = name;
2286       failure_delete_queue = temp;
2287
2288     already2:;
2289     }
2290 }
2291
2292 /* Delete all the temporary files whose names we previously recorded.  */
2293
2294 #ifndef DELETE_IF_ORDINARY
2295 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2296 do                                                      \
2297   {                                                     \
2298     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2299       if (unlink (NAME) < 0)                            \
2300         if (VERBOSE_FLAG)                               \
2301           perror_with_name (NAME);                      \
2302   } while (0)
2303 #endif
2304
2305 static void
2306 delete_if_ordinary (const char *name)
2307 {
2308   struct stat st;
2309 #ifdef DEBUG
2310   int i, c;
2311
2312   printf ("Delete %s? (y or n) ", name);
2313   fflush (stdout);
2314   i = getchar ();
2315   if (i != '\n')
2316     while ((c = getchar ()) != '\n' && c != EOF)
2317       ;
2318
2319   if (i == 'y' || i == 'Y')
2320 #endif /* DEBUG */
2321   DELETE_IF_ORDINARY (name, st, verbose_flag);
2322 }
2323
2324 static void
2325 delete_temp_files (void)
2326 {
2327   struct temp_file *temp;
2328
2329   for (temp = always_delete_queue; temp; temp = temp->next)
2330     delete_if_ordinary (temp->name);
2331   always_delete_queue = 0;
2332 }
2333
2334 /* Delete all the files to be deleted on error.  */
2335
2336 static void
2337 delete_failure_queue (void)
2338 {
2339   struct temp_file *temp;
2340
2341   for (temp = failure_delete_queue; temp; temp = temp->next)
2342     delete_if_ordinary (temp->name);
2343 }
2344
2345 static void
2346 clear_failure_queue (void)
2347 {
2348   failure_delete_queue = 0;
2349 }
2350 \f
2351 /* Build a list of search directories from PATHS.
2352    PREFIX is a string to prepend to the list.
2353    If CHECK_DIR_P is nonzero we ensure the directory exists.
2354    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2355    It is also used by the --print-search-dirs flag.  */
2356
2357 static char *
2358 build_search_list (struct path_prefix *paths, const char *prefix,
2359                    int check_dir_p)
2360 {
2361   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2362   int just_suffix_len
2363     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2364   int first_time = TRUE;
2365   struct prefix_list *pprefix;
2366
2367   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2368   obstack_1grow (&collect_obstack, '=');
2369
2370   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2371     {
2372       int len = strlen (pprefix->prefix);
2373
2374       if (machine_suffix
2375           && (! check_dir_p
2376               || is_directory (pprefix->prefix, machine_suffix, 0)))
2377         {
2378           if (!first_time)
2379             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2380
2381           first_time = FALSE;
2382           obstack_grow (&collect_obstack, pprefix->prefix, len);
2383           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2384         }
2385
2386       if (just_machine_suffix
2387           && pprefix->require_machine_suffix == 2
2388           && (! check_dir_p
2389               || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2390         {
2391           if (! first_time)
2392             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2393
2394           first_time = FALSE;
2395           obstack_grow (&collect_obstack, pprefix->prefix, len);
2396           obstack_grow (&collect_obstack, just_machine_suffix,
2397                         just_suffix_len);
2398         }
2399
2400       if (! pprefix->require_machine_suffix)
2401         {
2402           if (! first_time)
2403             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2404
2405           first_time = FALSE;
2406           obstack_grow (&collect_obstack, pprefix->prefix, len);
2407         }
2408     }
2409
2410   obstack_1grow (&collect_obstack, '\0');
2411   return obstack_finish (&collect_obstack);
2412 }
2413
2414 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2415    for collect.  */
2416
2417 static void
2418 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2419 {
2420   putenv (build_search_list (paths, env_var, 1));
2421 }
2422 \f
2423 /* Check whether NAME can be accessed in MODE.  This is like access,
2424    except that it never considers directories to be executable.  */
2425
2426 static int
2427 access_check (const char *name, int mode)
2428 {
2429   if (mode == X_OK)
2430     {
2431       struct stat st;
2432
2433       if (stat (name, &st) < 0
2434           || S_ISDIR (st.st_mode))
2435         return -1;
2436     }
2437
2438   return access (name, mode);
2439 }
2440
2441 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2442    access to check permissions.
2443    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2444
2445 static char *
2446 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2447              int multilib)
2448 {
2449   char *temp;
2450   const char *const file_suffix =
2451     ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2452   struct prefix_list *pl;
2453   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2454   const char *multilib_name, *multilib_os_name;
2455
2456 #ifdef DEFAULT_ASSEMBLER
2457   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2458     return xstrdup (DEFAULT_ASSEMBLER);
2459 #endif
2460
2461 #ifdef DEFAULT_LINKER
2462   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2463     return xstrdup (DEFAULT_LINKER);
2464 #endif
2465
2466   if (machine_suffix)
2467     len += strlen (machine_suffix);
2468
2469   multilib_name = name;
2470   multilib_os_name = name;
2471   if (multilib && multilib_os_dir)
2472     {
2473       int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2474       int len2 = strlen (multilib_os_dir) + 1;
2475
2476       len += len1 > len2 ? len1 : len2;
2477       if (multilib_dir)
2478         multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2479                                   NULL));
2480       if (strcmp (multilib_os_dir, ".") != 0)
2481         multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2482                                     NULL));
2483     }
2484
2485   temp = xmalloc (len);
2486
2487   /* Determine the filename to execute (special case for absolute paths).  */
2488
2489   if (IS_ABSOLUTE_PATH (name))
2490     {
2491       if (access (name, mode) == 0)
2492         {
2493           strcpy (temp, name);
2494           return temp;
2495         }
2496     }
2497   else
2498     for (pl = pprefix->plist; pl; pl = pl->next)
2499       {
2500         const char *this_name
2501           = pl->os_multilib ? multilib_os_name : multilib_name;
2502
2503         if (machine_suffix)
2504           {
2505             /* Some systems have a suffix for executable files.
2506                So try appending that first.  */
2507             if (file_suffix[0] != 0)
2508               {
2509                 strcpy (temp, pl->prefix);
2510                 strcat (temp, machine_suffix);
2511                 strcat (temp, multilib_name);
2512                 strcat (temp, file_suffix);
2513                 if (access_check (temp, mode) == 0)
2514                   return temp;
2515               }
2516
2517             /* Now try just the multilib_name.  */
2518             strcpy (temp, pl->prefix);
2519             strcat (temp, machine_suffix);
2520             strcat (temp, multilib_name);
2521             if (access_check (temp, mode) == 0)
2522               return temp;
2523           }
2524
2525         /* Certain prefixes are tried with just the machine type,
2526            not the version.  This is used for finding as, ld, etc.  */
2527         if (just_machine_suffix && pl->require_machine_suffix == 2)
2528           {
2529             /* Some systems have a suffix for executable files.
2530                So try appending that first.  */
2531             if (file_suffix[0] != 0)
2532               {
2533                 strcpy (temp, pl->prefix);
2534                 strcat (temp, just_machine_suffix);
2535                 strcat (temp, multilib_name);
2536                 strcat (temp, file_suffix);
2537                 if (access_check (temp, mode) == 0)
2538                   return temp;
2539               }
2540
2541             strcpy (temp, pl->prefix);
2542             strcat (temp, just_machine_suffix);
2543             strcat (temp, multilib_name);
2544             if (access_check (temp, mode) == 0)
2545               return temp;
2546           }
2547
2548         /* Certain prefixes can't be used without the machine suffix
2549            when the machine or version is explicitly specified.  */
2550         if (! pl->require_machine_suffix)
2551           {
2552             /* Some systems have a suffix for executable files.
2553                So try appending that first.  */
2554             if (file_suffix[0] != 0)
2555               {
2556                 strcpy (temp, pl->prefix);
2557                 strcat (temp, this_name);
2558                 strcat (temp, file_suffix);
2559                 if (access_check (temp, mode) == 0)
2560                   return temp;
2561               }
2562
2563             strcpy (temp, pl->prefix);
2564             strcat (temp, this_name);
2565             if (access_check (temp, mode) == 0)
2566               return temp;
2567           }
2568       }
2569
2570   free (temp);
2571   return 0;
2572 }
2573
2574 /* Ranking of prefixes in the sort list. -B prefixes are put before
2575    all others.  */
2576
2577 enum path_prefix_priority
2578 {
2579   PREFIX_PRIORITY_B_OPT,
2580   PREFIX_PRIORITY_LAST
2581 };
2582
2583 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2584    order according to PRIORITY.  Within each PRIORITY, new entries are
2585    appended.
2586
2587    If WARN is nonzero, we will warn if no file is found
2588    through this prefix.  WARN should point to an int
2589    which will be set to 1 if this entry is used.
2590
2591    COMPONENT is the value to be passed to update_path.
2592
2593    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2594    the complete value of machine_suffix.
2595    2 means try both machine_suffix and just_machine_suffix.  */
2596
2597 static void
2598 add_prefix (struct path_prefix *pprefix, const char *prefix,
2599             const char *component, /* enum prefix_priority */ int priority,
2600             int require_machine_suffix, int os_multilib)
2601 {
2602   struct prefix_list *pl, **prev;
2603   int len;
2604
2605   for (prev = &pprefix->plist;
2606        (*prev) != NULL && (*prev)->priority <= priority;
2607        prev = &(*prev)->next)
2608     ;
2609
2610   /* Keep track of the longest prefix.  */
2611
2612   prefix = update_path (prefix, component);
2613   len = strlen (prefix);
2614   if (len > pprefix->max_len)
2615     pprefix->max_len = len;
2616
2617   pl = xmalloc (sizeof (struct prefix_list));
2618   pl->prefix = prefix;
2619   pl->require_machine_suffix = require_machine_suffix;
2620   pl->priority = priority;
2621   pl->os_multilib = os_multilib;
2622
2623   /* Insert after PREV.  */
2624   pl->next = (*prev);
2625   (*prev) = pl;
2626 }
2627
2628 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2629 static void
2630 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2631                       const char *component,
2632                       /* enum prefix_priority */ int priority,
2633                       int require_machine_suffix, int os_multilib)
2634 {
2635   if (!IS_ABSOLUTE_PATH (prefix))
2636     fatal ("system path '%s' is not absolute", prefix);
2637
2638   if (target_system_root)
2639     {
2640       if (target_sysroot_suffix)
2641           prefix = concat (target_sysroot_suffix, prefix, NULL);
2642       prefix = concat (target_system_root, prefix, NULL);
2643
2644       /* We have to override this because GCC's notion of sysroot
2645          moves along with GCC.  */
2646       component = "GCC";
2647     }
2648
2649   add_prefix (pprefix, prefix, component, priority,
2650               require_machine_suffix, os_multilib);
2651 }
2652 \f
2653 /* Execute the command specified by the arguments on the current line of spec.
2654    When using pipes, this includes several piped-together commands
2655    with `|' between them.
2656
2657    Return 0 if successful, -1 if failed.  */
2658
2659 static int
2660 execute (void)
2661 {
2662   int i;
2663   int n_commands;               /* # of command.  */
2664   char *string;
2665   struct command
2666   {
2667     const char *prog;           /* program name.  */
2668     const char **argv;          /* vector of args.  */
2669     int pid;                    /* pid of process for this command.  */
2670   };
2671
2672   struct command *commands;     /* each command buffer with above info.  */
2673
2674   gcc_assert (!processing_spec_function);
2675
2676   /* Count # of piped commands.  */
2677   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2678     if (strcmp (argbuf[i], "|") == 0)
2679       n_commands++;
2680
2681   /* Get storage for each command.  */
2682   commands = alloca (n_commands * sizeof (struct command));
2683
2684   /* Split argbuf into its separate piped processes,
2685      and record info about each one.
2686      Also search for the programs that are to be run.  */
2687
2688   commands[0].prog = argbuf[0]; /* first command.  */
2689   commands[0].argv = &argbuf[0];
2690   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2691
2692   if (string)
2693     commands[0].argv[0] = string;
2694
2695   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2696     if (strcmp (argbuf[i], "|") == 0)
2697       {                         /* each command.  */
2698 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2699         fatal ("-pipe not supported");
2700 #endif
2701         argbuf[i] = 0;  /* termination of command args.  */
2702         commands[n_commands].prog = argbuf[i + 1];
2703         commands[n_commands].argv = &argbuf[i + 1];
2704         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2705                               X_OK, 0);
2706         if (string)
2707           commands[n_commands].argv[0] = string;
2708         n_commands++;
2709       }
2710
2711   argbuf[argbuf_index] = 0;
2712
2713   /* If -v, print what we are about to do, and maybe query.  */
2714
2715   if (verbose_flag)
2716     {
2717       /* For help listings, put a blank line between sub-processes.  */
2718       if (print_help_list)
2719         fputc ('\n', stderr);
2720
2721       /* Print each piped command as a separate line.  */
2722       for (i = 0; i < n_commands; i++)
2723         {
2724           const char *const *j;
2725
2726           if (verbose_only_flag)
2727             {
2728               for (j = commands[i].argv; *j; j++)
2729                 {
2730                   const char *p;
2731                   fprintf (stderr, " \"");
2732                   for (p = *j; *p; ++p)
2733                     {
2734                       if (*p == '"' || *p == '\\' || *p == '$')
2735                         fputc ('\\', stderr);
2736                       fputc (*p, stderr);
2737                     }
2738                   fputc ('"', stderr);
2739                 }
2740             }
2741           else
2742             for (j = commands[i].argv; *j; j++)
2743               fprintf (stderr, " %s", *j);
2744
2745           /* Print a pipe symbol after all but the last command.  */
2746           if (i + 1 != n_commands)
2747             fprintf (stderr, " |");
2748           fprintf (stderr, "\n");
2749         }
2750       fflush (stderr);
2751       if (verbose_only_flag != 0)
2752         {
2753           /* verbose_only_flag should act as if the spec was
2754              executed, so increment execution_count before
2755              returning.  This prevents spurious warnings about
2756              unused linker input files, etc.  */
2757           execution_count++;
2758           return 0;
2759         }
2760 #ifdef DEBUG
2761       notice ("\nGo ahead? (y or n) ");
2762       fflush (stderr);
2763       i = getchar ();
2764       if (i != '\n')
2765         while (getchar () != '\n')
2766           ;
2767
2768       if (i != 'y' && i != 'Y')
2769         return 0;
2770 #endif /* DEBUG */
2771     }
2772
2773 #ifdef ENABLE_VALGRIND_CHECKING
2774   /* Run the each command through valgrind.  To simplify prepending the
2775      path to valgrind and the option "-q" (for quiet operation unless
2776      something triggers), we allocate a separate argv array.  */
2777
2778   for (i = 0; i < n_commands; i++)
2779     {
2780       const char **argv;
2781       int argc;
2782       int j;
2783
2784       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2785         ;
2786
2787       argv = alloca ((argc + 3) * sizeof (char *));
2788
2789       argv[0] = VALGRIND_PATH;
2790       argv[1] = "-q";
2791       for (j = 2; j < argc + 2; j++)
2792         argv[j] = commands[i].argv[j - 2];
2793       argv[j] = NULL;
2794
2795       commands[i].argv = argv;
2796       commands[i].prog = argv[0];
2797     }
2798 #endif
2799
2800   /* Run each piped subprocess.  */
2801
2802   for (i = 0; i < n_commands; i++)
2803     {
2804       char *errmsg_fmt, *errmsg_arg;
2805       const char *string = commands[i].argv[0];
2806
2807       /* For some bizarre reason, the second argument of execvp() is
2808          char *const *, not const char *const *.  */
2809       commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2810                                   programname, temp_filename,
2811                                   &errmsg_fmt, &errmsg_arg,
2812                                   ((i == 0 ? PEXECUTE_FIRST : 0)
2813                                    | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2814                                    | (string == commands[i].prog
2815                                       ? PEXECUTE_SEARCH : 0)
2816                                    | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2817
2818       if (commands[i].pid == -1)
2819         pfatal_pexecute (errmsg_fmt, errmsg_arg);
2820
2821       if (string != commands[i].prog)
2822         free ((void *) string);
2823     }
2824
2825   execution_count++;
2826
2827   /* Wait for all the subprocesses to finish.
2828      We don't care what order they finish in;
2829      we know that N_COMMANDS waits will get them all.
2830      Ignore subprocesses that we don't know about,
2831      since they can be spawned by the process that exec'ed us.  */
2832
2833   {
2834     int ret_code = 0;
2835 #ifdef HAVE_GETRUSAGE
2836     struct timeval d;
2837     double ut = 0.0, st = 0.0;
2838 #endif
2839
2840     for (i = 0; i < n_commands;)
2841       {
2842         int j;
2843         int status;
2844         int pid;
2845
2846         pid = pwait (commands[i].pid, &status, 0);
2847         gcc_assert (pid >= 0);
2848
2849 #ifdef HAVE_GETRUSAGE
2850         if (report_times)
2851           {
2852             /* getrusage returns the total resource usage of all children
2853                up to now.  Copy the previous values into prus, get the
2854                current statistics, then take the difference.  */
2855
2856             prus = rus;
2857             getrusage (RUSAGE_CHILDREN, &rus);
2858             d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2859             d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2860             ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2861
2862             d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2863             d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2864             st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2865           }
2866 #endif
2867
2868         for (j = 0; j < n_commands; j++)
2869           if (commands[j].pid == pid)
2870             {
2871               i++;
2872               if (WIFSIGNALED (status))
2873                 {
2874 #ifdef SIGPIPE
2875                   /* SIGPIPE is a special case.  It happens in -pipe mode
2876                      when the compiler dies before the preprocessor is
2877                      done, or the assembler dies before the compiler is
2878                      done.  There's generally been an error already, and
2879                      this is just fallout.  So don't generate another error
2880                      unless we would otherwise have succeeded.  */
2881                   if (WTERMSIG (status) == SIGPIPE
2882                       && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2883                     ;
2884                   else
2885 #endif
2886                     fatal ("\
2887 Internal error: %s (program %s)\n\
2888 Please submit a full bug report.\n\
2889 See %s for instructions.",
2890                            strsignal (WTERMSIG (status)), commands[j].prog,
2891                            bug_report_url);
2892                   signal_count++;
2893                   ret_code = -1;
2894                 }
2895               else if (WIFEXITED (status)
2896                        && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2897                 {
2898                   if (WEXITSTATUS (status) > greatest_status)
2899                     greatest_status = WEXITSTATUS (status);
2900                   ret_code = -1;
2901                 }
2902 #ifdef HAVE_GETRUSAGE
2903               if (report_times && ut + st != 0)
2904                 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2905 #endif
2906               break;
2907             }
2908       }
2909     return ret_code;
2910   }
2911 }
2912 \f
2913 /* Find all the switches given to us
2914    and make a vector describing them.
2915    The elements of the vector are strings, one per switch given.
2916    If a switch uses following arguments, then the `part1' field
2917    is the switch itself and the `args' field
2918    is a null-terminated vector containing the following arguments.
2919    The `live_cond' field is:
2920    0 when initialized
2921    1 if the switch is true in a conditional spec,
2922    -1 if false (overridden by a later switch)
2923    -2 if this switch should be ignored (used in %<S)
2924    The `validated' field is nonzero if any spec has looked at this switch;
2925    if it remains zero at the end of the run, it must be meaningless.  */
2926
2927 #define SWITCH_OK       0
2928 #define SWITCH_FALSE   -1
2929 #define SWITCH_IGNORE  -2
2930 #define SWITCH_LIVE     1
2931
2932 struct switchstr
2933 {
2934   const char *part1;
2935   const char **args;
2936   int live_cond;
2937   unsigned char validated;
2938   unsigned char ordering;
2939 };
2940
2941 static struct switchstr *switches;
2942
2943 static int n_switches;
2944
2945 struct infile
2946 {
2947   const char *name;
2948   const char *language;
2949   struct compiler *incompiler;
2950   bool compiled;
2951   bool preprocessed;
2952 };
2953
2954 /* Also a vector of input files specified.  */
2955
2956 static struct infile *infiles;
2957
2958 int n_infiles;
2959
2960 /* True if multiple input files are being compiled to a single
2961    assembly file.  */
2962
2963 static bool combine_inputs;
2964
2965 /* This counts the number of libraries added by lang_specific_driver, so that
2966    we can tell if there were any user supplied any files or libraries.  */
2967
2968 static int added_libraries;
2969
2970 /* And a vector of corresponding output files is made up later.  */
2971
2972 const char **outfiles;
2973 \f
2974 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2975
2976 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2977    is true if we should look for an executable suffix.  DO_OBJ
2978    is true if we should look for an object suffix.  */
2979
2980 static const char *
2981 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2982                   int do_obj ATTRIBUTE_UNUSED)
2983 {
2984 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2985   int i;
2986 #endif
2987   int len;
2988
2989   if (name == NULL)
2990     return NULL;
2991
2992   len = strlen (name);
2993
2994 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2995   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2996   if (do_obj && len > 2
2997       && name[len - 2] == '.'
2998       && name[len - 1] == 'o')
2999     {
3000       obstack_grow (&obstack, name, len - 2);
3001       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3002       name = obstack_finish (&obstack);
3003     }
3004 #endif
3005
3006 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3007   /* If there is no filetype, make it the executable suffix (which includes
3008      the ".").  But don't get confused if we have just "-o".  */
3009   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3010     return name;
3011
3012   for (i = len - 1; i >= 0; i--)
3013     if (IS_DIR_SEPARATOR (name[i]))
3014       break;
3015
3016   for (i++; i < len; i++)
3017     if (name[i] == '.')
3018       return name;
3019
3020   obstack_grow (&obstack, name, len);
3021   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3022                  strlen (TARGET_EXECUTABLE_SUFFIX));
3023   name = obstack_finish (&obstack);
3024 #endif
3025
3026   return name;
3027 }
3028 #endif
3029 \f
3030 /* Display the command line switches accepted by gcc.  */
3031 static void
3032 display_help (void)
3033 {
3034   printf (_("Usage: %s [options] file...\n"), programname);
3035   fputs (_("Options:\n"), stdout);
3036
3037   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3038   fputs (_("  --help                   Display this information\n"), stdout);
3039   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3040   if (! verbose_flag)
3041     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3042   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3043   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3044   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3045   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3046   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3047   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3048   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3049   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3050   fputs (_("\
3051   -print-multi-lib         Display the mapping between command line options and\n\
3052                            multiple library search directories\n"), stdout);
3053   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3054   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3055   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3056   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3057   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3058   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3059   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3060   fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3061   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3062   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3063   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3064   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3065   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3066   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3067   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3068   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3069   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3070   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3071   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3072   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3073   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3074   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3075   fputs (_("\
3076   -x <language>            Specify the language of the following input files\n\
3077                            Permissible languages include: c c++ assembler none\n\
3078                            'none' means revert to the default behavior of\n\
3079                            guessing the language based on the file's extension\n\
3080 "), stdout);
3081
3082   printf (_("\
3083 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3084  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3085  other options on to these processes the -W<letter> options must be used.\n\
3086 "), programname);
3087
3088   /* The rest of the options are displayed by invocations of the various
3089      sub-processes.  */
3090 }
3091
3092 static void
3093 add_preprocessor_option (const char *option, int len)
3094 {
3095   n_preprocessor_options++;
3096
3097   if (! preprocessor_options)
3098     preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3099   else
3100     preprocessor_options = xrealloc (preprocessor_options,
3101                                      n_preprocessor_options * sizeof (char *));
3102
3103   preprocessor_options [n_preprocessor_options - 1] =
3104     save_string (option, len);
3105 }
3106
3107 static void
3108 add_assembler_option (const char *option, int len)
3109 {
3110   n_assembler_options++;
3111
3112   if (! assembler_options)
3113     assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3114   else
3115     assembler_options = xrealloc (assembler_options,
3116                                   n_assembler_options * sizeof (char *));
3117
3118   assembler_options [n_assembler_options - 1] = save_string (option, len);
3119 }
3120
3121 static void
3122 add_linker_option (const char *option, int len)
3123 {
3124   n_linker_options++;
3125
3126   if (! linker_options)
3127     linker_options = xmalloc (n_linker_options * sizeof (char *));
3128   else
3129     linker_options = xrealloc (linker_options,
3130                                n_linker_options * sizeof (char *));
3131
3132   linker_options [n_linker_options - 1] = save_string (option, len);
3133 }
3134 \f
3135 /* Create the vector `switches' and its contents.
3136    Store its length in `n_switches'.  */
3137
3138 static void
3139 process_command (int argc, const char **argv)
3140 {
3141   int i;
3142   const char *temp;
3143   char *temp1;
3144   const char *spec_lang = 0;
3145   int last_language_n_infiles;
3146   int have_c = 0;
3147   int lang_n_infiles = 0;
3148 #ifdef MODIFY_TARGET_NAME
3149   int is_modify_target_name;
3150   int j;
3151 #endif
3152
3153   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3154
3155   n_switches = 0;
3156   n_infiles = 0;
3157   added_libraries = 0;
3158
3159   /* Figure compiler version from version string.  */
3160
3161   compiler_version = temp1 = xstrdup (version_string);
3162
3163   for (; *temp1; ++temp1)
3164     {
3165       if (*temp1 == ' ')
3166         {
3167           *temp1 = '\0';
3168           break;
3169         }
3170     }
3171
3172   /* If there is a -V or -b option (or both), process it now, before
3173      trying to interpret the rest of the command line.  */
3174   if (argc > 1 && argv[1][0] == '-'
3175       && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3176     {
3177       const char *new_version = DEFAULT_TARGET_VERSION;
3178       const char *new_machine = DEFAULT_TARGET_MACHINE;
3179       const char *progname = argv[0];
3180       char **new_argv;
3181       char *new_argv0;
3182       int baselen;
3183
3184       while (argc > 1 && argv[1][0] == '-'
3185              && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3186         {
3187           char opt = argv[1][1];
3188           const char *arg;
3189           if (argv[1][2] != '\0')
3190             {
3191               arg = argv[1] + 2;
3192               argc -= 1;
3193               argv += 1;
3194             }
3195           else if (argc > 2)
3196             {
3197               arg = argv[2];
3198               argc -= 2;
3199               argv += 2;
3200             }
3201           else
3202             fatal ("'-%c' option must have argument", opt);
3203           if (opt == 'V')
3204             new_version = arg;
3205           else
3206             new_machine = arg;
3207         }
3208
3209       for (baselen = strlen (progname); baselen > 0; baselen--)
3210         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3211           break;
3212       new_argv0 = xmemdup (progname, baselen,
3213                            baselen + concat_length (new_version, new_machine,
3214                                                     "-gcc-", NULL) + 1);
3215       strcpy (new_argv0 + baselen, new_machine);
3216       strcat (new_argv0, "-gcc-");
3217       strcat (new_argv0, new_version);
3218
3219       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3220                           (argc + 1) * sizeof (argv[0]));
3221       new_argv[0] = new_argv0;
3222
3223       execvp (new_argv0, new_argv);
3224       fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3225     }
3226
3227   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3228      see if we can create it from the pathname specified in argv[0].  */
3229
3230   gcc_libexec_prefix = standard_libexec_prefix;
3231 #ifndef VMS
3232   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3233   if (!gcc_exec_prefix)
3234     {
3235       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3236                                               standard_exec_prefix);
3237       gcc_libexec_prefix = make_relative_prefix (argv[0],
3238                                                  standard_bindir_prefix,
3239                                                  standard_libexec_prefix);
3240       if (gcc_exec_prefix)
3241         putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3242     }
3243   else
3244     gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3245                                                standard_exec_prefix,
3246                                                standard_libexec_prefix);
3247 #else
3248 #endif
3249
3250   if (gcc_exec_prefix)
3251     {
3252       int len = strlen (gcc_exec_prefix);
3253
3254       if (len > (int) sizeof ("/lib/gcc/") - 1
3255           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3256         {
3257           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3258           if (IS_DIR_SEPARATOR (*temp)
3259               && strncmp (temp + 1, "lib", 3) == 0
3260               && IS_DIR_SEPARATOR (temp[4])
3261               && strncmp (temp + 5, "gcc", 3) == 0)
3262             len -= sizeof ("/lib/gcc/") - 1;
3263         }
3264
3265       set_std_prefix (gcc_exec_prefix, len);
3266       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3267                   PREFIX_PRIORITY_LAST, 0, 0);
3268       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3269                   PREFIX_PRIORITY_LAST, 0, 0);
3270     }
3271
3272   /* COMPILER_PATH and LIBRARY_PATH have values
3273      that are lists of directory names with colons.  */
3274
3275   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3276   if (temp)
3277     {
3278       const char *startp, *endp;
3279       char *nstore = alloca (strlen (temp) + 3);
3280
3281       startp = endp = temp;
3282       while (1)
3283         {
3284           if (*endp == PATH_SEPARATOR || *endp == 0)
3285             {
3286               strncpy (nstore, startp, endp - startp);
3287               if (endp == startp)
3288                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3289               else if (!IS_DIR_SEPARATOR (endp[-1]))
3290                 {
3291                   nstore[endp - startp] = DIR_SEPARATOR;
3292                   nstore[endp - startp + 1] = 0;
3293                 }
3294               else
3295                 nstore[endp - startp] = 0;
3296               add_prefix (&exec_prefixes, nstore, 0,
3297                           PREFIX_PRIORITY_LAST, 0, 0);
3298               add_prefix (&include_prefixes, nstore, 0,
3299                           PREFIX_PRIORITY_LAST, 0, 0);
3300               if (*endp == 0)
3301                 break;
3302               endp = startp = endp + 1;
3303             }
3304           else
3305             endp++;
3306         }
3307     }
3308
3309   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3310   if (temp && *cross_compile == '0')
3311     {
3312       const char *startp, *endp;
3313       char *nstore = alloca (strlen (temp) + 3);
3314
3315       startp = endp = temp;
3316       while (1)
3317         {
3318           if (*endp == PATH_SEPARATOR || *endp == 0)
3319             {
3320               strncpy (nstore, startp, endp - startp);
3321               if (endp == startp)
3322                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3323               else if (!IS_DIR_SEPARATOR (endp[-1]))
3324                 {
3325                   nstore[endp - startp] = DIR_SEPARATOR;
3326                   nstore[endp - startp + 1] = 0;
3327                 }
3328               else
3329                 nstore[endp - startp] = 0;
3330               add_prefix (&startfile_prefixes, nstore, NULL,
3331                           PREFIX_PRIORITY_LAST, 0, 1);
3332               if (*endp == 0)
3333                 break;
3334               endp = startp = endp + 1;
3335             }
3336           else
3337             endp++;
3338         }
3339     }
3340
3341   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3342   GET_ENVIRONMENT (temp, "LPATH");
3343   if (temp && *cross_compile == '0')
3344     {
3345       const char *startp, *endp;
3346       char *nstore = alloca (strlen (temp) + 3);
3347
3348       startp = endp = temp;
3349       while (1)
3350         {
3351           if (*endp == PATH_SEPARATOR || *endp == 0)
3352             {
3353               strncpy (nstore, startp, endp - startp);
3354               if (endp == startp)
3355                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3356               else if (!IS_DIR_SEPARATOR (endp[-1]))
3357                 {
3358                   nstore[endp - startp] = DIR_SEPARATOR;
3359                   nstore[endp - startp + 1] = 0;
3360                 }
3361               else
3362                 nstore[endp - startp] = 0;
3363               add_prefix (&startfile_prefixes, nstore, NULL,
3364                           PREFIX_PRIORITY_LAST, 0, 1);
3365               if (*endp == 0)
3366                 break;
3367               endp = startp = endp + 1;
3368             }
3369           else
3370             endp++;
3371         }
3372     }
3373
3374   /* Convert new-style -- options to old-style.  */
3375   translate_options (&argc, (const char *const **) &argv);
3376
3377   /* Do language-specific adjustment/addition of flags.  */
3378   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3379
3380   /* Scan argv twice.  Here, the first time, just count how many switches
3381      there will be in their vector, and how many input files in theirs.
3382      Here we also parse the switches that cc itself uses (e.g. -v).  */
3383
3384   for (i = 1; i < argc; i++)
3385     {
3386       if (! strcmp (argv[i], "-dumpspecs"))
3387         {
3388           struct spec_list *sl;
3389           init_spec ();
3390           for (sl = specs; sl; sl = sl->next)
3391             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3392           if (link_command_spec)
3393             printf ("*link_command:\n%s\n\n", link_command_spec);
3394           exit (0);
3395         }
3396       else if (! strcmp (argv[i], "-dumpversion"))
3397         {
3398           printf ("%s\n", spec_version);
3399           exit (0);
3400         }
3401       else if (! strcmp (argv[i], "-dumpmachine"))
3402         {
3403           printf ("%s\n", spec_machine);
3404           exit (0);
3405         }
3406       else if (strcmp (argv[i], "-fversion") == 0)
3407         {
3408           /* translate_options () has turned --version into -fversion.  */
3409           printf (_("%s (GCC) %s\n"), programname, version_string);
3410           printf ("Copyright %s 2004 Free Software Foundation, Inc.\n",
3411                   _("(C)"));
3412           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3413 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3414                  stdout);
3415           exit (0);
3416         }
3417       else if (strcmp (argv[i], "-fhelp") == 0)
3418         {
3419           /* translate_options () has turned --help into -fhelp.  */
3420           print_help_list = 1;
3421
3422           /* We will be passing a dummy file on to the sub-processes.  */
3423           n_infiles++;
3424           n_switches++;
3425
3426           /* CPP driver cannot obtain switch from cc1_options.  */
3427           if (is_cpp_driver)
3428             add_preprocessor_option ("--help", 6);
3429           add_assembler_option ("--help", 6);
3430           add_linker_option ("--help", 6);
3431         }
3432       else if (strcmp (argv[i], "-ftarget-help") == 0)
3433         {
3434           /* translate_options() has turned --target-help into -ftarget-help.  */
3435           target_help_flag = 1;
3436
3437           /* We will be passing a dummy file on to the sub-processes.  */
3438           n_infiles++;
3439           n_switches++;
3440
3441           /* CPP driver cannot obtain switch from cc1_options.  */
3442           if (is_cpp_driver)
3443             add_preprocessor_option ("--target-help", 13);
3444           add_assembler_option ("--target-help", 13);
3445           add_linker_option ("--target-help", 13);
3446         }
3447       else if (! strcmp (argv[i], "-pass-exit-codes"))
3448         {
3449           pass_exit_codes = 1;
3450           n_switches++;
3451         }
3452       else if (! strcmp (argv[i], "-print-search-dirs"))
3453         print_search_dirs = 1;
3454       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3455         print_file_name = "libgcc.a";
3456       else if (! strncmp (argv[i], "-print-file-name=", 17))
3457         print_file_name = argv[i] + 17;
3458       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3459         print_prog_name = argv[i] + 17;
3460       else if (! strcmp (argv[i], "-print-multi-lib"))
3461         print_multi_lib = 1;
3462       else if (! strcmp (argv[i], "-print-multi-directory"))
3463         print_multi_directory = 1;
3464       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3465         print_multi_os_directory = 1;
3466       else if (! strncmp (argv[i], "-Wa,", 4))
3467         {
3468           int prev, j;
3469           /* Pass the rest of this option to the assembler.  */
3470
3471           /* Split the argument at commas.  */
3472           prev = 4;
3473           for (j = 4; argv[i][j]; j++)
3474             if (argv[i][j] == ',')
3475               {
3476                 add_assembler_option (argv[i] + prev, j - prev);
3477                 prev = j + 1;
3478               }
3479
3480           /* Record the part after the last comma.  */
3481           add_assembler_option (argv[i] + prev, j - prev);
3482         }
3483       else if (! strncmp (argv[i], "-Wp,", 4))
3484         {
3485           int prev, j;
3486           /* Pass the rest of this option to the preprocessor.  */
3487
3488           /* Split the argument at commas.  */
3489           prev = 4;
3490           for (j = 4; argv[i][j]; j++)
3491             if (argv[i][j] == ',')
3492               {
3493                 add_preprocessor_option (argv[i] + prev, j - prev);
3494                 prev = j + 1;
3495               }
3496
3497           /* Record the part after the last comma.  */
3498           add_preprocessor_option (argv[i] + prev, j - prev);
3499         }
3500       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3501         /* The +e options to the C++ front-end.  */
3502         n_switches++;
3503       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3504         {
3505           int j;
3506           /* Split the argument at commas.  */
3507           for (j = 3; argv[i][j]; j++)
3508             n_infiles += (argv[i][j] == ',');
3509         }
3510       else if (strcmp (argv[i], "-Xlinker") == 0)
3511         {
3512           if (i + 1 == argc)
3513             fatal ("argument to '-Xlinker' is missing");
3514
3515           n_infiles++;
3516           i++;
3517         }
3518       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3519         {
3520           if (i + 1 == argc)
3521             fatal ("argument to '-Xpreprocessor' is missing");
3522
3523           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3524         }
3525       else if (strcmp (argv[i], "-Xassembler") == 0)
3526         {
3527           if (i + 1 == argc)
3528             fatal ("argument to '-Xassembler' is missing");
3529
3530           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3531         }
3532       else if (strcmp (argv[i], "-l") == 0)
3533         {
3534           if (i + 1 == argc)
3535             fatal ("argument to '-l' is missing");
3536
3537           n_infiles++;
3538           i++;
3539         }
3540       else if (strncmp (argv[i], "-l", 2) == 0)
3541         n_infiles++;
3542       else if (strcmp (argv[i], "-save-temps") == 0)
3543         {
3544           save_temps_flag = 1;
3545           n_switches++;
3546         }
3547       else if (strcmp (argv[i], "-combine") == 0)
3548         {
3549           combine_flag = 1;
3550           n_switches++;
3551         }
3552       else if (strcmp (argv[i], "-specs") == 0)
3553         {
3554           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3555           if (++i >= argc)
3556             fatal ("argument to '-specs' is missing");
3557
3558           user->next = (struct user_specs *) 0;
3559           user->filename = argv[i];
3560           if (user_specs_tail)
3561             user_specs_tail->next = user;
3562           else
3563             user_specs_head = user;
3564           user_specs_tail = user;
3565         }
3566       else if (strncmp (argv[i], "-specs=", 7) == 0)
3567         {
3568           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3569           if (strlen (argv[i]) == 7)
3570             fatal ("argument to '-specs=' is missing");
3571
3572           user->next = (struct user_specs *) 0;
3573           user->filename = argv[i] + 7;
3574           if (user_specs_tail)
3575             user_specs_tail->next = user;
3576           else
3577             user_specs_head = user;
3578           user_specs_tail = user;
3579         }
3580       else if (strcmp (argv[i], "-time") == 0)
3581         report_times = 1;
3582       else if (strcmp (argv[i], "-pipe") == 0)
3583         {
3584           /* -pipe has to go into the switches array as well as
3585              setting a flag.  */
3586           use_pipes = 1;
3587           n_switches++;
3588         }
3589       else if (strcmp (argv[i], "-###") == 0)
3590         {
3591           /* This is similar to -v except that there is no execution
3592              of the commands and the echoed arguments are quoted.  It
3593              is intended for use in shell scripts to capture the
3594              driver-generated command line.  */
3595           verbose_only_flag++;
3596           verbose_flag++;
3597         }
3598       else if (argv[i][0] == '-' && argv[i][1] != 0)
3599         {
3600           const char *p = &argv[i][1];
3601           int c = *p;
3602
3603           switch (c)
3604             {
3605             case 'b':
3606             case 'V':
3607               fatal ("'-%c' must come at the start of the command line", c);
3608               break;
3609
3610             case 'B':
3611               {
3612                 const char *value;
3613                 int len;
3614
3615                 if (p[1] == 0 && i + 1 == argc)
3616                   fatal ("argument to '-B' is missing");
3617                 if (p[1] == 0)
3618                   value = argv[++i];
3619                 else
3620                   value = p + 1;
3621
3622                 len = strlen (value);
3623
3624                 /* Catch the case where the user has forgotten to append a
3625                    directory separator to the path.  Note, they may be using
3626                    -B to add an executable name prefix, eg "i386-elf-", in
3627                    order to distinguish between multiple installations of
3628                    GCC in the same directory.  Hence we must check to see
3629                    if appending a directory separator actually makes a
3630                    valid directory name.  */
3631                 if (! IS_DIR_SEPARATOR (value [len - 1])
3632                     && is_directory (value, "", 0))
3633                   {
3634                     char *tmp = xmalloc (len + 2);
3635                     strcpy (tmp, value);
3636                     tmp[len] = DIR_SEPARATOR;
3637                     tmp[++ len] = 0;
3638                     value = tmp;
3639                   }
3640
3641                 /* As a kludge, if the arg is "[foo/]stageN/", just
3642                    add "[foo/]include" to the include prefix.  */
3643                 if ((len == 7
3644                      || (len > 7
3645                          && (IS_DIR_SEPARATOR (value[len - 8]))))
3646                     && strncmp (value + len - 7, "stage", 5) == 0
3647                     && ISDIGIT (value[len - 2])
3648                     && (IS_DIR_SEPARATOR (value[len - 1])))
3649                   {
3650                     if (len == 7)
3651                       add_prefix (&include_prefixes, "./", NULL,
3652                                   PREFIX_PRIORITY_B_OPT, 0, 0);
3653                     else
3654                       {
3655                         char *string = xmalloc (len - 6);
3656                         memcpy (string, value, len - 7);
3657                         string[len - 7] = 0;
3658                         add_prefix (&include_prefixes, string, NULL,
3659                                     PREFIX_PRIORITY_B_OPT, 0, 0);
3660                       }
3661                   }
3662
3663                 add_prefix (&exec_prefixes, value, NULL,
3664                             PREFIX_PRIORITY_B_OPT, 0, 0);
3665                 add_prefix (&startfile_prefixes, value, NULL,
3666                             PREFIX_PRIORITY_B_OPT, 0, 0);
3667                 add_prefix (&include_prefixes, value, NULL,
3668                             PREFIX_PRIORITY_B_OPT, 0, 0);
3669                 n_switches++;
3670               }
3671               break;
3672
3673             case 'v':   /* Print our subcommands and print versions.  */
3674               n_switches++;
3675               /* If they do anything other than exactly `-v', don't set
3676                  verbose_flag; rather, continue on to give the error.  */
3677               if (p[1] != 0)
3678                 break;
3679               verbose_flag++;
3680               break;
3681
3682             case 'S':
3683             case 'c':
3684               if (p[1] == 0)
3685                 {
3686                   have_c = 1;
3687                   n_switches++;
3688                   break;
3689                 }
3690               goto normal_switch;
3691
3692             case 'o':
3693 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3694               if (! have_c)
3695                 {
3696                   int skip;
3697
3698                   /* Forward scan, just in case -S or -c is specified
3699                      after -o.  */
3700                   int j = i + 1;
3701                   if (p[1] == 0)
3702                     ++j;
3703                   while (j < argc)
3704                     {
3705                       if (argv[j][0] == '-')
3706                         {
3707                           if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3708                               && argv[j][2] == 0)
3709                             {
3710                               have_c = 1;
3711                               break;
3712                             }
3713                           else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3714                             j += skip - (argv[j][2] != 0);
3715                           else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3716                             j += skip;
3717                         }
3718                       j++;
3719                     }
3720                 }
3721 #endif
3722 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3723               if (p[1] == 0)
3724                 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3725               else
3726                 argv[i] = convert_filename (argv[i], ! have_c, 0);
3727 #endif
3728               goto normal_switch;
3729
3730             default:
3731             normal_switch:
3732
3733 #ifdef MODIFY_TARGET_NAME
3734               is_modify_target_name = 0;
3735
3736               for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3737                 if (! strcmp (argv[i], modify_target[j].sw))
3738                   {
3739                     char *new_name = xmalloc (strlen (modify_target[j].str)
3740                                               + strlen (spec_machine));
3741                     const char *p, *r;
3742                     char *q;
3743                     int made_addition = 0;
3744
3745                     is_modify_target_name = 1;
3746                     for (p = spec_machine, q = new_name; *p != 0; )
3747                       {
3748                         if (modify_target[j].add_del == DELETE
3749                             && (! strncmp (q, modify_target[j].str,
3750                                            strlen (modify_target[j].str))))
3751                           p += strlen (modify_target[j].str);
3752                         else if (modify_target[j].add_del == ADD
3753                                  && ! made_addition && *p == '-')
3754                           {
3755                             for (r = modify_target[j].str; *r != 0; )
3756                               *q++ = *r++;
3757                             made_addition = 1;
3758                           }
3759
3760                         *q++ = *p++;
3761                       }
3762
3763                     spec_machine = new_name;
3764                   }
3765
3766               if (is_modify_target_name)
3767                 break;
3768 #endif
3769
3770               n_switches++;
3771
3772               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3773                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3774               else if (WORD_SWITCH_TAKES_ARG (p))
3775                 i += WORD_SWITCH_TAKES_ARG (p);
3776             }
3777         }
3778       else
3779         {
3780           n_infiles++;
3781           lang_n_infiles++;
3782         }
3783     }
3784
3785   if ((save_temps_flag || report_times) && use_pipes)
3786     {
3787       /* -save-temps overrides -pipe, so that temp files are produced */
3788       if (save_temps_flag)
3789         error ("warning: -pipe ignored because -save-temps specified");
3790       /* -time overrides -pipe because we can't get correct stats when
3791          multiple children are running at once.  */
3792       else if (report_times)
3793         error ("warning: -pipe ignored because -time specified");
3794
3795       use_pipes = 0;
3796     }
3797
3798   /* Set up the search paths before we go looking for config files.  */
3799
3800   /* These come before the md prefixes so that we will find gcc's subcommands
3801      (such as cpp) rather than those of the host system.  */
3802   /* Use 2 as fourth arg meaning try just the machine as a suffix,
3803      as well as trying the machine and the version.  */
3804 #ifndef OS2
3805   add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3806               PREFIX_PRIORITY_LAST, 1, 0);
3807   add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3808               PREFIX_PRIORITY_LAST, 2, 0);
3809   add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3810               PREFIX_PRIORITY_LAST, 2, 0);
3811   add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3812               PREFIX_PRIORITY_LAST, 2, 0);
3813   add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3814               PREFIX_PRIORITY_LAST, 2, 0);
3815 #endif
3816
3817   add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3818               PREFIX_PRIORITY_LAST, 1, 0);
3819   add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
3820               PREFIX_PRIORITY_LAST, 1, 0);
3821
3822   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3823                            dir_separator_str, NULL);
3824
3825   /* If tooldir is relative, base it on exec_prefixes.  A relative
3826      tooldir lets us move the installed tree as a unit.
3827
3828      If GCC_EXEC_PREFIX is defined, then we want to add two relative
3829      directories, so that we can search both the user specified directory
3830      and the standard place.  */
3831
3832   if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3833     {
3834       if (gcc_exec_prefix)
3835         {
3836           char *gcc_exec_tooldir_prefix
3837             = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3838                       spec_version, dir_separator_str, tooldir_prefix, NULL);
3839
3840           add_prefix (&exec_prefixes,
3841                       concat (gcc_exec_tooldir_prefix, "bin",
3842                               dir_separator_str, NULL),
3843                       NULL, PREFIX_PRIORITY_LAST, 0, 0);
3844           add_prefix (&startfile_prefixes,
3845                       concat (gcc_exec_tooldir_prefix, "lib",
3846                               dir_separator_str, NULL),
3847                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
3848         }
3849
3850       tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3851                                dir_separator_str, spec_version,
3852                                dir_separator_str, tooldir_prefix, NULL);
3853     }
3854
3855   add_prefix (&exec_prefixes,
3856               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3857               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3858   add_prefix (&startfile_prefixes,
3859               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3860               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3861
3862 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3863   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3864      then consider it to relocate with the rest of the GCC installation
3865      if GCC_EXEC_PREFIX is set.
3866      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3867   if (target_system_root && gcc_exec_prefix)
3868     {
3869       char *tmp_prefix = make_relative_prefix (argv[0],
3870                                                standard_bindir_prefix,
3871                                                target_system_root);
3872       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3873         {
3874           target_system_root = tmp_prefix;
3875           target_system_root_changed = 1;
3876         }
3877     }
3878 #endif
3879
3880   /* More prefixes are enabled in main, after we read the specs file
3881      and determine whether this is cross-compilation or not.  */
3882
3883   /* Then create the space for the vectors and scan again.  */
3884
3885   switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3886   infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3887   n_switches = 0;
3888   n_infiles = 0;
3889   last_language_n_infiles = -1;
3890
3891   /* This, time, copy the text of each switch and store a pointer
3892      to the copy in the vector of switches.
3893      Store all the infiles in their vector.  */
3894
3895   for (i = 1; i < argc; i++)
3896     {
3897       /* Just skip the switches that were handled by the preceding loop.  */
3898 #ifdef MODIFY_TARGET_NAME
3899       is_modify_target_name = 0;
3900
3901       for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3902         if (! strcmp (argv[i], modify_target[j].sw))
3903           is_modify_target_name = 1;
3904
3905       if (is_modify_target_name)
3906         ;
3907       else
3908 #endif
3909       if (! strncmp (argv[i], "-Wa,", 4))
3910         ;
3911       else if (! strncmp (argv[i], "-Wp,", 4))
3912         ;
3913       else if (! strcmp (argv[i], "-pass-exit-codes"))
3914         ;
3915       else if (! strcmp (argv[i], "-print-search-dirs"))
3916         ;
3917       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3918         ;
3919       else if (! strncmp (argv[i], "-print-file-name=", 17))
3920         ;
3921       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3922         ;
3923       else if (! strcmp (argv[i], "-print-multi-lib"))
3924         ;
3925       else if (! strcmp (argv[i], "-print-multi-directory"))
3926         ;
3927       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3928         ;
3929       else if (! strcmp (argv[i], "-ftarget-help"))
3930         ;
3931       else if (! strcmp (argv[i], "-fhelp"))
3932         ;
3933       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3934         {
3935           /* Compensate for the +e options to the C++ front-end;
3936              they're there simply for cfront call-compatibility.  We do
3937              some magic in default_compilers to pass them down properly.
3938              Note we deliberately start at the `+' here, to avoid passing
3939              -e0 or -e1 down into the linker.  */
3940           switches[n_switches].part1 = &argv[i][0];
3941           switches[n_switches].args = 0;
3942           switches[n_switches].live_cond = SWITCH_OK;
3943           switches[n_switches].validated = 0;
3944           n_switches++;
3945         }
3946       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3947         {
3948           int prev, j;
3949           /* Split the argument at commas.  */
3950           prev = 4;
3951           for (j = 4; argv[i][j]; j++)
3952             if (argv[i][j] == ',')
3953               {
3954                 infiles[n_infiles].language = "*";
3955                 infiles[n_infiles++].name
3956                   = save_string (argv[i] + prev, j - prev);
3957                 prev = j + 1;
3958               }
3959           /* Record the part after the last comma.  */
3960           infiles[n_infiles].language = "*";
3961           infiles[n_infiles++].name = argv[i] + prev;
3962         }
3963       else if (strcmp (argv[i], "-Xlinker") == 0)
3964         {
3965           infiles[n_infiles].language = "*";
3966           infiles[n_infiles++].name = argv[++i];
3967         }
3968       else if (strcmp (argv[i], "-Xassembler") == 0)
3969         {
3970           infiles[n_infiles].language = "*";
3971           infiles[n_infiles++].name = argv[++i];
3972         }
3973       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3974         {
3975           infiles[n_infiles].language = "*";
3976           infiles[n_infiles++].name = argv[++i];
3977         }
3978       else if (strcmp (argv[i], "-l") == 0)
3979         { /* POSIX allows separation of -l and the lib arg;
3980              canonicalize by concatenating -l with its arg */
3981           infiles[n_infiles].language = "*";
3982           infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3983         }
3984       else if (strncmp (argv[i], "-l", 2) == 0)
3985         {
3986           infiles[n_infiles].language = "*";
3987           infiles[n_infiles++].name = argv[i];
3988         }
3989       else if (strcmp (argv[i], "-specs") == 0)
3990         i++;
3991       else if (strncmp (argv[i], "-specs=", 7) == 0)
3992         ;
3993       else if (strcmp (argv[i], "-time") == 0)
3994         ;
3995       else if (strcmp (argv[i], "-###") == 0)
3996         ;
3997       else if (argv[i][0] == '-' && argv[i][1] != 0)
3998         {
3999           const char *p = &argv[i][1];
4000           int c = *p;
4001
4002           if (c == 'x')
4003             {
4004               if (p[1] == 0 && i + 1 == argc)
4005                 fatal ("argument to '-x' is missing");
4006               if (p[1] == 0)
4007                 spec_lang = argv[++i];
4008               else
4009                 spec_lang = p + 1;
4010               if (! strcmp (spec_lang, "none"))
4011                 /* Suppress the warning if -xnone comes after the last input
4012                    file, because alternate command interfaces like g++ might
4013                    find it useful to place -xnone after each input file.  */
4014                 spec_lang = 0;
4015               else
4016                 last_language_n_infiles = n_infiles;
4017               continue;
4018             }
4019           switches[n_switches].part1 = p;
4020           /* Deal with option arguments in separate argv elements.  */
4021           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4022               || WORD_SWITCH_TAKES_ARG (p))
4023             {
4024               int j = 0;
4025               int n_args = WORD_SWITCH_TAKES_ARG (p);
4026
4027               if (n_args == 0)
4028                 {
4029                   /* Count only the option arguments in separate argv elements.  */
4030                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4031                 }
4032               if (i + n_args >= argc)
4033                 fatal ("argument to '-%s' is missing", p);
4034               switches[n_switches].args
4035                 = xmalloc ((n_args + 1) * sizeof(const char *));
4036               while (j < n_args)
4037                 switches[n_switches].args[j++] = argv[++i];
4038               /* Null-terminate the vector.  */
4039               switches[n_switches].args[j] = 0;
4040             }
4041           else if (strchr (switches_need_spaces, c))
4042             {
4043               /* On some systems, ld cannot handle some options without
4044                  a space.  So split the option from its argument.  */
4045               char *part1 = xmalloc (2);
4046               part1[0] = c;
4047               part1[1] = '\0';
4048
4049               switches[n_switches].part1 = part1;
4050               switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4051               switches[n_switches].args[0] = xstrdup (p+1);
4052               switches[n_switches].args[1] = 0;
4053             }
4054           else
4055             switches[n_switches].args = 0;
4056
4057           switches[n_switches].live_cond = SWITCH_OK;
4058           switches[n_switches].validated = 0;
4059           switches[n_switches].ordering = 0;
4060           /* These are always valid, since gcc.c itself understands them.  */
4061           if (!strcmp (p, "save-temps")
4062               || !strcmp (p, "static-libgcc")
4063               || !strcmp (p, "shared-libgcc")
4064               || !strcmp (p, "pipe"))
4065             switches[n_switches].validated = 1;
4066           else
4067             {
4068               char ch = switches[n_switches].part1[0];
4069               if (ch == 'B')
4070                 switches[n_switches].validated = 1;
4071             }
4072           n_switches++;
4073         }
4074       else
4075         {
4076 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4077           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4078 #endif
4079
4080           if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4081             {
4082               perror_with_name (argv[i]);
4083               error_count++;
4084             }
4085           else
4086             {
4087               infiles[n_infiles].language = spec_lang;
4088               infiles[n_infiles++].name = argv[i];
4089             }
4090         }
4091     }
4092
4093   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4094     error ("warning: '-x %s' after last input file has no effect", spec_lang);
4095
4096   /* Ensure we only invoke each subprocess once.  */
4097   if (target_help_flag || print_help_list)
4098     {
4099       n_infiles = 1;
4100
4101       /* Create a dummy input file, so that we can pass --target-help on to
4102          the various sub-processes.  */
4103       infiles[0].language = "c";
4104       infiles[0].name   = "help-dummy";
4105
4106       if (target_help_flag)
4107         {
4108           switches[n_switches].part1     = "--target-help";
4109           switches[n_switches].args      = 0;
4110           switches[n_switches].live_cond = SWITCH_OK;
4111           switches[n_switches].validated = 0;
4112
4113           n_switches++;
4114         }
4115
4116       if (print_help_list)
4117         {
4118           switches[n_switches].part1     = "--help";
4119           switches[n_switches].args      = 0;
4120           switches[n_switches].live_cond = SWITCH_OK;
4121           switches[n_switches].validated = 0;
4122
4123           n_switches++;
4124         }
4125     }
4126
4127   switches[n_switches].part1 = 0;
4128   infiles[n_infiles].name = 0;
4129 }
4130
4131 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4132    and place that in the environment.  */
4133
4134 static void
4135 set_collect_gcc_options (void)
4136 {
4137   int i;
4138   int first_time;
4139
4140   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4141      the compiler.  */
4142   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4143                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4144
4145   first_time = TRUE;
4146   for (i = 0; (int) i < n_switches; i++)
4147     {
4148       const char *const *args;
4149       const char *p, *q;
4150       if (!first_time)
4151         obstack_grow (&collect_obstack, " ", 1);
4152
4153       first_time = FALSE;
4154
4155       /* Ignore elided switches.  */
4156       if (switches[i].live_cond == SWITCH_IGNORE)
4157         continue;
4158
4159       obstack_grow (&collect_obstack, "'-", 2);
4160       q = switches[i].part1;
4161       while ((p = strchr (q, '\'')))
4162         {
4163           obstack_grow (&collect_obstack, q, p - q);
4164           obstack_grow (&collect_obstack, "'\\''", 4);
4165           q = ++p;
4166         }
4167       obstack_grow (&collect_obstack, q, strlen (q));
4168       obstack_grow (&collect_obstack, "'", 1);
4169
4170       for (args = switches[i].args; args && *args; args++)
4171         {
4172           obstack_grow (&collect_obstack, " '", 2);
4173           q = *args;
4174           while ((p = strchr (q, '\'')))
4175             {
4176               obstack_grow (&collect_obstack, q, p - q);
4177               obstack_grow (&collect_obstack, "'\\''", 4);
4178               q = ++p;
4179             }
4180           obstack_grow (&collect_obstack, q, strlen (q));
4181           obstack_grow (&collect_obstack, "'", 1);
4182         }
4183     }
4184   obstack_grow (&collect_obstack, "\0", 1);
4185   putenv (obstack_finish (&collect_obstack));
4186 }
4187 \f
4188 /* Process a spec string, accumulating and running commands.  */
4189
4190 /* These variables describe the input file name.
4191    input_file_number is the index on outfiles of this file,
4192    so that the output file name can be stored for later use by %o.
4193    input_basename is the start of the part of the input file
4194    sans all directory names, and basename_length is the number
4195    of characters starting there excluding the suffix .c or whatever.  */
4196
4197 static const char *input_filename;
4198 static int input_file_number;
4199 size_t input_filename_length;
4200 static int basename_length;
4201 static int suffixed_basename_length;
4202 static const char *input_basename;
4203 static const char *input_suffix;
4204 #ifndef HOST_LACKS_INODE_NUMBERS
4205 static struct stat input_stat;
4206 #endif
4207 static int input_stat_set;
4208
4209 /* The compiler used to process the current input file.  */
4210 static struct compiler *input_file_compiler;
4211
4212 /* These are variables used within do_spec and do_spec_1.  */
4213
4214 /* Nonzero if an arg has been started and not yet terminated
4215    (with space, tab or newline).  */
4216 static int arg_going;
4217
4218 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4219    is a temporary file name.  */
4220 static int delete_this_arg;
4221
4222 /* Nonzero means %w has been seen; the next arg to be terminated
4223    is the output file name of this compilation.  */
4224 static int this_is_output_file;
4225
4226 /* Nonzero means %s has been seen; the next arg to be terminated
4227    is the name of a library file and we should try the standard
4228    search dirs for it.  */
4229 static int this_is_library_file;
4230
4231 /* Nonzero means that the input of this command is coming from a pipe.  */
4232 static int input_from_pipe;
4233
4234 /* Nonnull means substitute this for any suffix when outputting a switches
4235    arguments.  */
4236 static const char *suffix_subst;
4237
4238 /* Process the spec SPEC and run the commands specified therein.
4239    Returns 0 if the spec is successfully processed; -1 if failed.  */
4240
4241 int
4242 do_spec (const char *spec)
4243 {
4244   int value;
4245
4246   value = do_spec_2 (spec);
4247
4248   /* Force out any unfinished command.
4249      If -pipe, this forces out the last command if it ended in `|'.  */
4250   if (value == 0)
4251     {
4252       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4253         argbuf_index--;
4254
4255       set_collect_gcc_options ();
4256
4257       if (argbuf_index > 0)
4258         value = execute ();
4259     }
4260
4261   return value;
4262 }
4263
4264 static int
4265 do_spec_2 (const char *spec)
4266 {
4267   const char *string;
4268   int result;
4269
4270   clear_args ();
4271   arg_going = 0;
4272   delete_this_arg = 0;
4273   this_is_output_file = 0;
4274   this_is_library_file = 0;
4275   input_from_pipe = 0;
4276   suffix_subst = NULL;
4277
4278   result = do_spec_1 (spec, 0, NULL);
4279
4280   /* End any pending argument.  */
4281   if (arg_going)
4282     {
4283       obstack_1grow (&obstack, 0);
4284       string = obstack_finish (&obstack);
4285       if (this_is_library_file)
4286         string = find_file (string);
4287       store_arg (string, delete_this_arg, this_is_output_file);
4288       if (this_is_output_file)
4289         outfiles[input_file_number] = string;
4290       arg_going = 0;
4291     }
4292
4293   return result;
4294 }
4295
4296
4297 /* Process the given spec string and add any new options to the end
4298    of the switches/n_switches array.  */
4299
4300 static void
4301 do_option_spec (const char *name, const char *spec)
4302 {
4303   unsigned int i, value_count, value_len;
4304   const char *p, *q, *value;
4305   char *tmp_spec, *tmp_spec_p;
4306
4307   if (configure_default_options[0].name == NULL)
4308     return;
4309
4310   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4311     if (strcmp (configure_default_options[i].name, name) == 0)
4312       break;
4313   if (i == ARRAY_SIZE (configure_default_options))
4314     return;
4315
4316   value = configure_default_options[i].value;
4317   value_len = strlen (value);
4318
4319   /* Compute the size of the final spec.  */
4320   value_count = 0;
4321   p = spec;
4322   while ((p = strstr (p, "%(VALUE)")) != NULL)
4323     {
4324       p ++;
4325       value_count ++;
4326     }
4327
4328   /* Replace each %(VALUE) by the specified value.  */
4329   tmp_spec = alloca (strlen (spec) + 1
4330                      + value_count * (value_len - strlen ("%(VALUE)")));
4331   tmp_spec_p = tmp_spec;
4332   q = spec;
4333   while ((p = strstr (q, "%(VALUE)")) != NULL)
4334     {
4335       memcpy (tmp_spec_p, q, p - q);
4336       tmp_spec_p = tmp_spec_p + (p - q);
4337       memcpy (tmp_spec_p, value, value_len);
4338       tmp_spec_p += value_len;
4339       q = p + strlen ("%(VALUE)");
4340     }
4341   strcpy (tmp_spec_p, q);
4342
4343   do_self_spec (tmp_spec);
4344 }
4345
4346 /* Process the given spec string and add any new options to the end
4347    of the switches/n_switches array.  */
4348
4349 static void
4350 do_self_spec (const char *spec)
4351 {
4352   do_spec_2 (spec);
4353   do_spec_1 (" ", 0, NULL);
4354
4355   if (argbuf_index > 0)
4356     {
4357       int i, first;
4358
4359       first = n_switches;
4360       n_switches += argbuf_index;
4361       switches = xrealloc (switches,
4362                            sizeof (struct switchstr) * (n_switches + 1));
4363
4364       switches[n_switches] = switches[first];
4365       for (i = 0; i < argbuf_index; i++)
4366         {
4367           struct switchstr *sw;
4368
4369           /* Each switch should start with '-'.  */
4370           if (argbuf[i][0] != '-')
4371             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4372
4373           sw = &switches[i + first];
4374           sw->part1 = &argbuf[i][1];
4375           sw->args = 0;
4376           sw->live_cond = SWITCH_OK;
4377           sw->validated = 0;
4378           sw->ordering = 0;
4379         }
4380     }
4381 }
4382
4383 void
4384 do_spec_path (struct prefix_list *pl, const char *option,
4385               int omit_if_relative, int separate_options,
4386               int only_subdir,
4387               const char *dir_for_machine_suffix,
4388               const char *dir_for_no_suffix)
4389 {
4390   static size_t bufsize = 0;
4391   static char *buffer;
4392   int idx;
4393
4394   /* Used on systems which record the specified -L dirs
4395      and use them to search for dynamic linking.  */
4396   /* Relative directories always come from -B,
4397      and it is better not to use them for searching
4398      at run time.  In particular, stage1 loses.  */
4399   if (omit_if_relative
4400       && !IS_ABSOLUTE_PATH (pl->prefix))
4401     return;
4402
4403   /* Try subdirectory if there is one.  */
4404   if (machine_suffix && dir_for_machine_suffix)
4405     {
4406       if (strlen (pl->prefix) + strlen (machine_suffix)
4407           >= bufsize)
4408         bufsize = (strlen (pl->prefix)
4409                   + strlen (machine_suffix)) * 2 + 1;
4410       buffer = xrealloc (buffer, bufsize);
4411       strcpy (buffer, pl->prefix);
4412       strcat (buffer, machine_suffix);
4413       if (is_directory (buffer, dir_for_machine_suffix, 1))
4414         {
4415           do_spec_1 (option, separate_options, NULL);
4416           if (separate_options)
4417             do_spec_1 (" ", 0, NULL);
4418           do_spec_1 (buffer, 1, NULL);
4419           do_spec_1 (dir_for_machine_suffix, 1, NULL);
4420           /* Make this a separate argument.  */
4421           do_spec_1 (" ", 0, NULL);
4422         }
4423     }
4424   if (!pl->require_machine_suffix && dir_for_no_suffix)
4425     {
4426       if (is_directory (pl->prefix, dir_for_no_suffix, 1))
4427         {
4428           do_spec_1 (option, separate_options, NULL);
4429           if (separate_options)
4430             do_spec_1 (" ", 0, NULL);
4431           do_spec_1 (pl->prefix, 1, NULL);
4432           do_spec_1 (dir_for_no_suffix, 1, NULL);
4433           /* Make this a separate argument.  */
4434           do_spec_1 (" ", 0, NULL);
4435         }
4436     }
4437
4438   if (only_subdir)
4439     return;
4440
4441   if (machine_suffix)
4442     {
4443       if (is_directory (pl->prefix, machine_suffix, 1))
4444         {
4445           do_spec_1 (option, separate_options, NULL);
4446           if (separate_options)
4447             do_spec_1 (" ", 0, NULL);
4448           do_spec_1 (pl->prefix, 1, NULL);
4449           /* Remove slash from machine_suffix.  */
4450           if (strlen (machine_suffix) >= bufsize)
4451             bufsize = strlen (machine_suffix) * 2 + 1;
4452           buffer = xrealloc (buffer, bufsize);
4453           strcpy (buffer, machine_suffix);
4454           idx = strlen (buffer);
4455           if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4456             buffer[idx - 1] = 0;
4457           do_spec_1 (buffer, 1, NULL);
4458           /* Make this a separate argument.  */
4459           do_spec_1 (" ", 0, NULL);
4460         }
4461     }
4462   if (!pl->require_machine_suffix)
4463     {
4464       if (is_directory (pl->prefix, "", 1))
4465         {
4466           do_spec_1 (option, separate_options, NULL);
4467           if (separate_options)
4468             do_spec_1 (" ", 0, NULL);
4469           /* Remove slash from pl->prefix.  */
4470           if (strlen (pl->prefix) >= bufsize)
4471             bufsize = strlen (pl->prefix) * 2 + 1;
4472           buffer = xrealloc (buffer, bufsize);
4473           strcpy (buffer, pl->prefix);
4474           idx = strlen (buffer);
4475           if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4476             buffer[idx - 1] = 0;
4477           do_spec_1 (buffer, 1, NULL);
4478           /* Make this a separate argument.  */
4479           do_spec_1 (" ", 0, NULL);
4480         }
4481     }
4482 }
4483
4484 /* Process the sub-spec SPEC as a portion of a larger spec.
4485    This is like processing a whole spec except that we do
4486    not initialize at the beginning and we do not supply a
4487    newline by default at the end.
4488    INSWITCH nonzero means don't process %-sequences in SPEC;
4489    in this case, % is treated as an ordinary character.
4490    This is used while substituting switches.
4491    INSWITCH nonzero also causes SPC not to terminate an argument.
4492
4493    Value is zero unless a line was finished
4494    and the command on that line reported an error.  */
4495
4496 static int
4497 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4498 {
4499   const char *p = spec;
4500   int c;
4501   int i;
4502   const char *string;
4503   int value;
4504
4505   while ((c = *p++))
4506     /* If substituting a switch, treat all chars like letters.
4507        Otherwise, NL, SPC, TAB and % are special.  */
4508     switch (inswitch ? 'a' : c)
4509       {
4510       case '\n':
4511         /* End of line: finish any pending argument,
4512            then run the pending command if one has been started.  */
4513         if (arg_going)
4514           {
4515             obstack_1grow (&obstack, 0);
4516             string = obstack_finish (&obstack);
4517             if (this_is_library_file)
4518               string = find_file (string);
4519             store_arg (string, delete_this_arg, this_is_output_file);
4520             if (this_is_output_file)
4521               outfiles[input_file_number] = string;
4522           }
4523         arg_going = 0;
4524
4525         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4526           {
4527             /* A `|' before the newline means use a pipe here,
4528                but only if -pipe was specified.
4529                Otherwise, execute now and don't pass the `|' as an arg.  */
4530             if (use_pipes)
4531               {
4532                 input_from_pipe = 1;
4533                 break;
4534               }
4535             else
4536               argbuf_index--;
4537           }
4538
4539         set_collect_gcc_options ();
4540
4541         if (argbuf_index > 0)
4542           {
4543             value = execute ();
4544             if (value)
4545               return value;
4546           }
4547         /* Reinitialize for a new command, and for a new argument.  */
4548         clear_args ();
4549         arg_going = 0;
4550         delete_this_arg = 0;
4551         this_is_output_file = 0;
4552         this_is_library_file = 0;
4553         input_from_pipe = 0;
4554         break;
4555
4556       case '|':
4557         /* End any pending argument.  */
4558         if (arg_going)
4559           {
4560             obstack_1grow (&obstack, 0);
4561             string = obstack_finish (&obstack);
4562             if (this_is_library_file)
4563               string = find_file (string);
4564             store_arg (string, delete_this_arg, this_is_output_file);
4565             if (this_is_output_file)
4566               outfiles[input_file_number] = string;
4567           }
4568
4569         /* Use pipe */
4570         obstack_1grow (&obstack, c);
4571         arg_going = 1;
4572         break;
4573
4574       case '\t':
4575       case ' ':
4576         /* Space or tab ends an argument if one is pending.  */
4577         if (arg_going)
4578           {
4579             obstack_1grow (&obstack, 0);
4580             string = obstack_finish (&obstack);
4581             if (this_is_library_file)
4582               string = find_file (string);
4583             store_arg (string, delete_this_arg, this_is_output_file);
4584             if (this_is_output_file)
4585               outfiles[input_file_number] = string;
4586           }
4587         /* Reinitialize for a new argument.  */
4588         arg_going = 0;
4589         delete_this_arg = 0;
4590         this_is_output_file = 0;
4591         this_is_library_file = 0;
4592         break;
4593
4594       case '%':
4595         switch (c = *p++)
4596           {
4597           case 0:
4598             fatal ("spec '%s' invalid", spec);
4599
4600           case 'b':
4601             obstack_grow (&obstack, input_basename, basename_length);
4602             arg_going = 1;
4603             break;
4604
4605           case 'B':
4606             obstack_grow (&obstack, input_basename, suffixed_basename_length);
4607             arg_going = 1;
4608             break;
4609
4610           case 'd':
4611             delete_this_arg = 2;
4612             break;
4613
4614           /* Dump out the directories specified with LIBRARY_PATH,
4615              followed by the absolute directories
4616              that we search for startfiles.  */
4617           case 'D':
4618             {
4619               struct prefix_list *pl = startfile_prefixes.plist;
4620
4621               for (; pl; pl = pl->next)
4622                 {
4623                   const char *no_suffix_multilib_dir;
4624
4625                   no_suffix_multilib_dir = pl->os_multilib ? multilib_os_dir
4626                                            : multilib_dir;
4627                   /* Do not separate options, include non-multilibbed variant.  */
4628                   do_spec_path (pl, "-L",
4629 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4630                                 1,
4631 #else
4632                                 0,
4633 #endif
4634                                 0, 0, multilib_dir, no_suffix_multilib_dir);
4635                 }
4636             }
4637             break;
4638
4639           case 'e':
4640             /* %efoo means report an error with `foo' as error message
4641                and don't execute any more commands for this file.  */
4642             {
4643               const char *q = p;
4644               char *buf;
4645               while (*p != 0 && *p != '\n')
4646                 p++;
4647               buf = alloca (p - q + 1);
4648               strncpy (buf, q, p - q);
4649               buf[p - q] = 0;
4650               error ("%s", buf);
4651               return -1;
4652             }
4653             break;
4654           case 'n':
4655             /* %nfoo means report a notice with `foo' on stderr.  */
4656             {
4657               const char *q = p;
4658               char *buf;
4659               while (*p != 0 && *p != '\n')
4660                 p++;
4661               buf = alloca (p - q + 1);
4662               strncpy (buf, q, p - q);
4663               buf[p - q] = 0;
4664               notice ("%s\n", buf);
4665               if (*p)
4666                 p++;
4667             }
4668             break;
4669
4670           case 'j':
4671             {
4672               struct stat st;
4673
4674               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4675                  defined, and it is not a directory, and it is
4676                  writable, use it.  Otherwise, treat this like any
4677                  other temporary file.  */
4678
4679               if ((!save_temps_flag)
4680                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4681                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4682                 {
4683                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4684                                 strlen (HOST_BIT_BUCKET));
4685                   delete_this_arg = 0;
4686                   arg_going = 1;
4687                   break;
4688                 }
4689             }
4690             goto create_temp_file;
4691           case '|':
4692             if (use_pipes)
4693               {
4694                 obstack_1grow (&obstack, '-');
4695                 delete_this_arg = 0;
4696                 arg_going = 1;
4697
4698                 /* consume suffix */
4699                 while (*p == '.' || ISALPHA ((unsigned char) *p))
4700                   p++;
4701                 if (p[0] == '%' && p[1] == 'O')
4702                   p += 2;
4703
4704                 break;
4705               }
4706             goto create_temp_file;
4707           case 'm':
4708             if (use_pipes)
4709               {
4710                 /* consume suffix */
4711                 while (*p == '.' || ISALPHA ((unsigned char) *p))
4712                   p++;
4713                 if (p[0] == '%' && p[1] == 'O')
4714                   p += 2;
4715
4716                 break;
4717               }
4718             goto create_temp_file;
4719           case 'g':
4720           case 'u':
4721           case 'U':
4722           create_temp_file:
4723               {
4724                 struct temp_name *t;
4725                 int suffix_length;
4726                 const char *suffix = p;
4727                 char *saved_suffix = NULL;
4728
4729                 while (*p == '.' || ISALPHA ((unsigned char) *p))
4730                   p++;
4731                 suffix_length = p - suffix;
4732                 if (p[0] == '%' && p[1] == 'O')
4733                   {
4734                     p += 2;
4735                     /* We don't support extra suffix characters after %O.  */
4736                     if (*p == '.' || ISALPHA ((unsigned char) *p))
4737                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
4738                     if (suffix_length == 0)
4739                       suffix = TARGET_OBJECT_SUFFIX;
4740                     else
4741                       {
4742                         saved_suffix
4743                           = xmalloc (suffix_length
4744                                      + strlen (TARGET_OBJECT_SUFFIX));
4745                         strncpy (saved_suffix, suffix, suffix_length);
4746                         strcpy (saved_suffix + suffix_length,
4747                                 TARGET_OBJECT_SUFFIX);
4748                       }
4749                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4750                   }
4751
4752                 /* If the input_filename has the same suffix specified
4753                    for the %g, %u, or %U, and -save-temps is specified,
4754                    we could end up using that file as an intermediate
4755                    thus clobbering the user's source file (.e.g.,
4756                    gcc -save-temps foo.s would clobber foo.s with the
4757                    output of cpp0).  So check for this condition and
4758                    generate a temp file as the intermediate.  */
4759
4760                 if (save_temps_flag)
4761                   {
4762                     temp_filename_length = basename_length + suffix_length;
4763                     temp_filename = alloca (temp_filename_length + 1);
4764                     strncpy ((char *) temp_filename, input_basename, basename_length);
4765                     strncpy ((char *) temp_filename + basename_length, suffix,
4766                              suffix_length);
4767                     *((char *) temp_filename + temp_filename_length) = '\0';
4768                     if (strcmp (temp_filename, input_filename) != 0)
4769                       {
4770 #ifndef HOST_LACKS_INODE_NUMBERS
4771                         struct stat st_temp;
4772
4773                         /* Note, set_input() resets input_stat_set to 0.  */
4774                         if (input_stat_set == 0)
4775                           {
4776                             input_stat_set = stat (input_filename, &input_stat);
4777                             if (input_stat_set >= 0)
4778                               input_stat_set = 1;
4779                           }
4780
4781                         /* If we have the stat for the input_filename
4782                            and we can do the stat for the temp_filename
4783                            then the they could still refer to the same
4784                            file if st_dev/st_ino's are the same.  */
4785                         if (input_stat_set != 1
4786                             || stat (temp_filename, &st_temp) < 0
4787                             || input_stat.st_dev != st_temp.st_dev
4788                             || input_stat.st_ino != st_temp.st_ino)
4789 #else
4790                         /* Just compare canonical pathnames.  */
4791                         char* input_realname = lrealpath (input_filename);
4792                         char* temp_realname = lrealpath (temp_filename);
4793                         bool files_differ = strcmp (input_realname, temp_realname);
4794                         free (input_realname);
4795                         free (temp_realname);
4796                         if (files_differ)
4797 #endif
4798                           {
4799                             temp_filename = save_string (temp_filename,
4800                                                          temp_filename_length + 1);
4801                             obstack_grow (&obstack, temp_filename,
4802                                                     temp_filename_length);
4803                             arg_going = 1;
4804                             delete_this_arg = 0;
4805                             break;
4806                           }
4807                       }
4808                   }
4809
4810                 /* See if we already have an association of %g/%u/%U and
4811                    suffix.  */
4812                 for (t = temp_names; t; t = t->next)
4813                   if (t->length == suffix_length
4814                       && strncmp (t->suffix, suffix, suffix_length) == 0
4815                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4816                     break;
4817
4818                 /* Make a new association if needed.  %u and %j
4819                    require one.  */
4820                 if (t == 0 || c == 'u' || c == 'j')
4821                   {
4822                     if (t == 0)
4823                       {
4824                         t = xmalloc (sizeof (struct temp_name));
4825                         t->next = temp_names;
4826                         temp_names = t;
4827                       }
4828                     t->length = suffix_length;
4829                     if (saved_suffix)
4830                       {
4831                         t->suffix = saved_suffix;
4832                         saved_suffix = NULL;
4833                       }
4834                     else
4835                       t->suffix = save_string (suffix, suffix_length);
4836                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4837                     temp_filename = make_temp_file (t->suffix);
4838                     temp_filename_length = strlen (temp_filename);
4839                     t->filename = temp_filename;
4840                     t->filename_length = temp_filename_length;
4841                   }
4842
4843                 if (saved_suffix)
4844                   free (saved_suffix);
4845
4846                 obstack_grow (&obstack, t->filename, t->filename_length);
4847                 delete_this_arg = 1;
4848               }
4849             arg_going = 1;
4850             break;
4851
4852           case 'i':
4853             if (combine_inputs)
4854               {
4855                 for (i = 0; (int) i < n_infiles; i++)
4856                   if ((!infiles[i].language) || (infiles[i].language[0] != '*'))
4857                     if (infiles[i].incompiler == input_file_compiler)
4858                       {
4859                         store_arg (infiles[i].name, 0, 0);
4860                         infiles[i].compiled = true;
4861                       }
4862               }
4863             else
4864               {
4865                 obstack_grow (&obstack, input_filename, input_filename_length);
4866                 arg_going = 1;
4867               }
4868             break;
4869
4870           case 'I':
4871             {
4872               struct prefix_list *pl = include_prefixes.plist;
4873
4874               if (gcc_exec_prefix)
4875                 {
4876                   do_spec_1 ("-iprefix", 1, NULL);
4877                   /* Make this a separate argument.  */
4878                   do_spec_1 (" ", 0, NULL);
4879                   do_spec_1 (gcc_exec_prefix, 1, NULL);
4880                   do_spec_1 (" ", 0, NULL);
4881                 }
4882
4883               if (target_system_root_changed ||
4884                   (target_system_root && target_sysroot_hdrs_suffix))
4885                 {
4886                   do_spec_1 ("-isysroot", 1, NULL);
4887                   /* Make this a separate argument.  */
4888                   do_spec_1 (" ", 0, NULL);
4889                   do_spec_1 (target_system_root, 1, NULL);
4890                   if (target_sysroot_hdrs_suffix)
4891                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4892                   do_spec_1 (" ", 0, NULL);
4893                 }
4894
4895               for (; pl; pl = pl->next)
4896                 /* Separate options, don't include non-suffixed variant.  */
4897                 do_spec_path (pl, "-isystem", 0, 1, 1, "include", "include");
4898             }
4899             break;
4900
4901           case 'o':
4902             {
4903               int max = n_infiles;
4904               max += lang_specific_extra_outfiles;
4905
4906               for (i = 0; i < max; i++)
4907                 if (outfiles[i])
4908                   store_arg (outfiles[i], 0, 0);
4909               break;
4910             }
4911
4912           case 'O':
4913             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4914             arg_going = 1;
4915             break;
4916
4917           case 's':
4918             this_is_library_file = 1;
4919             break;
4920
4921           case 'V':
4922             outfiles[input_file_number] = NULL;
4923             break;
4924
4925           case 'w':
4926             this_is_output_file = 1;
4927             break;
4928
4929           case 'W':
4930             {
4931               int cur_index = argbuf_index;
4932               /* Handle the {...} following the %W.  */
4933               if (*p != '{')
4934                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
4935               p = handle_braces (p + 1);
4936               if (p == 0)
4937                 return -1;
4938               /* End any pending argument.  */
4939               if (arg_going)
4940                 {
4941                   obstack_1grow (&obstack, 0);
4942                   string = obstack_finish (&obstack);
4943                   if (this_is_library_file)
4944                     string = find_file (string);
4945                   store_arg (string, delete_this_arg, this_is_output_file);
4946                   if (this_is_output_file)
4947                     outfiles[input_file_number] = string;
4948                   arg_going = 0;
4949                 }
4950               /* If any args were output, mark the last one for deletion
4951                  on failure.  */
4952               if (argbuf_index != cur_index)
4953                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4954               break;
4955             }
4956
4957           /* %x{OPTION} records OPTION for %X to output.  */
4958           case 'x':
4959             {
4960               const char *p1 = p;
4961               char *string;
4962
4963               /* Skip past the option value and make a copy.  */
4964               if (*p != '{')
4965                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
4966               while (*p++ != '}')
4967                 ;
4968               string = save_string (p1 + 1, p - p1 - 2);
4969
4970               /* See if we already recorded this option.  */
4971               for (i = 0; i < n_linker_options; i++)
4972                 if (! strcmp (string, linker_options[i]))
4973                   {
4974                     free (string);
4975                     return 0;
4976                   }
4977
4978               /* This option is new; add it.  */
4979               add_linker_option (string, strlen (string));
4980             }
4981             break;
4982
4983           /* Dump out the options accumulated previously using %x.  */
4984           case 'X':
4985             for (i = 0; i < n_linker_options; i++)
4986               {
4987                 do_spec_1 (linker_options[i], 1, NULL);
4988                 /* Make each accumulated option a separate argument.  */
4989                 do_spec_1 (" ", 0, NULL);
4990               }
4991             break;
4992
4993           /* Dump out the options accumulated previously using -Wa,.  */
4994           case 'Y':
4995             for (i = 0; i < n_assembler_options; i++)
4996               {
4997                 do_spec_1 (assembler_options[i], 1, NULL);
4998                 /* Make each accumulated option a separate argument.  */
4999                 do_spec_1 (" ", 0, NULL);
5000               }
5001             break;
5002
5003           /* Dump out the options accumulated previously using -Wp,.  */
5004           case 'Z':
5005             for (i = 0; i < n_preprocessor_options; i++)
5006               {
5007                 do_spec_1 (preprocessor_options[i], 1, NULL);
5008                 /* Make each accumulated option a separate argument.  */
5009                 do_spec_1 (" ", 0, NULL);
5010               }
5011             break;
5012
5013             /* Here are digits and numbers that just process
5014                a certain constant string as a spec.  */
5015
5016           case '1':
5017             value = do_spec_1 (cc1_spec, 0, NULL);
5018             if (value != 0)
5019               return value;
5020             break;
5021
5022           case '2':
5023             value = do_spec_1 (cc1plus_spec, 0, NULL);
5024             if (value != 0)
5025               return value;
5026             break;
5027
5028           case 'a':
5029             value = do_spec_1 (asm_spec, 0, NULL);
5030             if (value != 0)
5031               return value;
5032             break;
5033
5034           case 'A':
5035             value = do_spec_1 (asm_final_spec, 0, NULL);
5036             if (value != 0)
5037               return value;
5038             break;
5039
5040           case 'C':
5041             {
5042               const char *const spec
5043                 = (input_file_compiler->cpp_spec
5044                    ? input_file_compiler->cpp_spec
5045                    : cpp_spec);
5046               value = do_spec_1 (spec, 0, NULL);
5047               if (value != 0)
5048                 return value;
5049             }
5050             break;
5051
5052           case 'E':
5053             value = do_spec_1 (endfile_spec, 0, NULL);
5054             if (value != 0)
5055               return value;
5056             break;
5057
5058           case 'l':
5059             value = do_spec_1 (link_spec, 0, NULL);
5060             if (value != 0)
5061               return value;
5062             break;
5063
5064           case 'L':
5065             value = do_spec_1 (lib_spec, 0, NULL);
5066             if (value != 0)
5067               return value;
5068             break;
5069
5070           case 'G':
5071             value = do_spec_1 (libgcc_spec, 0, NULL);
5072             if (value != 0)
5073               return value;
5074             break;
5075
5076           case 'M':
5077             if (multilib_dir && strcmp (multilib_dir, ".") != 0)
5078               {
5079                 char *p;
5080                 const char *q;
5081                 size_t len;
5082
5083                 len = strlen (multilib_dir);
5084                 obstack_blank (&obstack, len + 1);
5085                 p = obstack_next_free (&obstack) - (len + 1);
5086
5087                 *p++ = '_';
5088                 for (q = multilib_dir; *q ; ++q, ++p)
5089                   *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
5090               }
5091             break;
5092
5093           case 'R':
5094             /* We assume there is a directory
5095                separator at the end of this string.  */
5096             if (target_system_root)
5097               {
5098                 obstack_grow (&obstack, target_system_root,
5099                               strlen (target_system_root));
5100                 if (target_sysroot_suffix)
5101                   obstack_grow (&obstack, target_sysroot_suffix,
5102                                 strlen (target_sysroot_suffix));
5103               }
5104             break;
5105
5106           case 'S':
5107             value = do_spec_1 (startfile_spec, 0, NULL);
5108             if (value != 0)
5109               return value;
5110             break;
5111
5112             /* Here we define characters other than letters and digits.  */
5113
5114           case '{':
5115             p = handle_braces (p);
5116             if (p == 0)
5117               return -1;
5118             break;
5119
5120           case ':':
5121             p = handle_spec_function (p);
5122             if (p == 0)
5123               return -1;
5124             break;
5125
5126           case '%':
5127             obstack_1grow (&obstack, '%');
5128             break;
5129
5130           case '.':
5131             {
5132               unsigned len = 0;
5133
5134               while (p[len] && p[len] != ' ' && p[len] != '%')
5135                 len++;
5136               suffix_subst = save_string (p - 1, len + 1);
5137               p += len;
5138             }
5139            break;
5140
5141            /* Henceforth ignore the option(s) matching the pattern
5142               after the %<.  */
5143           case '<':
5144             {
5145               unsigned len = 0;
5146               int have_wildcard = 0;
5147               int i;
5148
5149               while (p[len] && p[len] != ' ' && p[len] != '\t')
5150                 len++;
5151
5152               if (p[len-1] == '*')
5153                 have_wildcard = 1;
5154
5155               for (i = 0; i < n_switches; i++)
5156                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5157                     && (have_wildcard || switches[i].part1[len] == '\0'))
5158                   {
5159                     switches[i].live_cond = SWITCH_IGNORE;
5160                     switches[i].validated = 1;
5161                   }
5162
5163               p += len;
5164             }
5165             break;
5166
5167           case '*':
5168             if (soft_matched_part)
5169               {
5170                 do_spec_1 (soft_matched_part, 1, NULL);
5171                 do_spec_1 (" ", 0, NULL);
5172               }
5173             else
5174               /* Catch the case where a spec string contains something like
5175                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5176                  hand side of the :.  */
5177               error ("spec failure: '%%*' has not been initialized by pattern match");
5178             break;
5179
5180             /* Process a string found as the value of a spec given by name.
5181                This feature allows individual machine descriptions
5182                to add and use their own specs.
5183                %[...] modifies -D options the way %P does;
5184                %(...) uses the spec unmodified.  */
5185           case '[':
5186             error ("warning: use of obsolete %%[ operator in specs");
5187           case '(':
5188             {
5189               const char *name = p;
5190               struct spec_list *sl;
5191               int len;
5192
5193               /* The string after the S/P is the name of a spec that is to be
5194                  processed.  */
5195               while (*p && *p != ')' && *p != ']')
5196                 p++;
5197
5198               /* See if it's in the list.  */
5199               for (len = p - name, sl = specs; sl; sl = sl->next)
5200                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5201                   {
5202                     name = *(sl->ptr_spec);
5203 #ifdef DEBUG_SPECS
5204                     notice ("Processing spec %c%s%c, which is '%s'\n",
5205                             c, sl->name, (c == '(') ? ')' : ']', name);
5206 #endif
5207                     break;
5208                   }
5209
5210               if (sl)
5211                 {
5212                   if (c == '(')
5213                     {
5214                       value = do_spec_1 (name, 0, NULL);
5215                       if (value != 0)
5216                         return value;
5217                     }
5218                   else
5219                     {
5220                       char *x = alloca (strlen (name) * 2 + 1);
5221                       char *buf = x;
5222                       const char *y = name;
5223                       int flag = 0;
5224
5225                       /* Copy all of NAME into BUF, but put __ after
5226                          every -D and at the end of each arg.  */
5227                       while (1)
5228                         {
5229                           if (! strncmp (y, "-D", 2))
5230                             {
5231                               *x++ = '-';
5232                               *x++ = 'D';
5233                               *x++ = '_';
5234                               *x++ = '_';
5235                               y += 2;
5236                               flag = 1;
5237                               continue;
5238                             }
5239                           else if (flag
5240                                    && (*y == ' ' || *y == '\t' || *y == '='
5241                                        || *y == '}' || *y == 0))
5242                             {
5243                               *x++ = '_';
5244                               *x++ = '_';
5245                               flag = 0;
5246                             }
5247                           if (*y == 0)
5248                             break;
5249                           else
5250                             *x++ = *y++;
5251                         }
5252                       *x = 0;
5253
5254                       value = do_spec_1 (buf, 0, NULL);
5255                       if (value != 0)
5256                         return value;
5257                     }
5258                 }
5259
5260               /* Discard the closing paren or bracket.  */
5261               if (*p)
5262                 p++;
5263             }
5264             break;
5265
5266           default:
5267             error ("spec failure: unrecognized spec option '%c'", c);
5268             break;
5269           }
5270         break;
5271
5272       case '\\':
5273         /* Backslash: treat next character as ordinary.  */
5274         c = *p++;
5275
5276         /* Fall through.  */
5277       default:
5278         /* Ordinary character: put it into the current argument.  */
5279         obstack_1grow (&obstack, c);
5280         arg_going = 1;
5281       }
5282
5283   /* End of string.  If we are processing a spec function, we need to
5284      end any pending argument.  */
5285   if (processing_spec_function && arg_going)
5286     {
5287       obstack_1grow (&obstack, 0);
5288       string = obstack_finish (&obstack);
5289       if (this_is_library_file)
5290         string = find_file (string);
5291       store_arg (string, delete_this_arg, this_is_output_file);
5292       if (this_is_output_file)
5293         outfiles[input_file_number] = string;
5294       arg_going = 0;
5295     }
5296
5297   return 0;
5298 }
5299
5300 /* Look up a spec function.  */
5301
5302 static const struct spec_function *
5303 lookup_spec_function (const char *name)
5304 {
5305   static const struct spec_function * const spec_function_tables[] =
5306   {
5307     static_spec_functions,
5308     lang_specific_spec_functions,
5309   };
5310   const struct spec_function *sf;
5311   unsigned int i;
5312
5313   for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
5314     {
5315       for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
5316         if (strcmp (sf->name, name) == 0)
5317           return sf;
5318     }
5319
5320   return NULL;
5321 }
5322
5323 /* Evaluate a spec function.  */
5324
5325 static const char *
5326 eval_spec_function (const char *func, const char *args)
5327 {
5328   const struct spec_function *sf;
5329   const char *funcval;
5330
5331   /* Saved spec processing context.  */
5332   int save_argbuf_index;
5333   int save_argbuf_length;
5334   const char **save_argbuf;
5335
5336   int save_arg_going;
5337   int save_delete_this_arg;
5338   int save_this_is_output_file;
5339   int save_this_is_library_file;
5340   int save_input_from_pipe;
5341   const char *save_suffix_subst;
5342
5343
5344   sf = lookup_spec_function (func);
5345   if (sf == NULL)
5346     fatal ("unknown spec function '%s'", func);
5347
5348   /* Push the spec processing context.  */
5349   save_argbuf_index = argbuf_index;
5350   save_argbuf_length = argbuf_length;
5351   save_argbuf = argbuf;
5352
5353   save_arg_going = arg_going;
5354   save_delete_this_arg = delete_this_arg;
5355   save_this_is_output_file = this_is_output_file;
5356   save_this_is_library_file = this_is_library_file;
5357   save_input_from_pipe = input_from_pipe;
5358   save_suffix_subst = suffix_subst;
5359
5360   /* Create a new spec processing context, and build the function
5361      arguments.  */
5362
5363   alloc_args ();
5364   if (do_spec_2 (args) < 0)
5365     fatal ("error in args to spec function '%s'", func);
5366
5367   /* argbuf_index is an index for the next argument to be inserted, and
5368      so contains the count of the args already inserted.  */
5369
5370   funcval = (*sf->func) (argbuf_index, argbuf);
5371
5372   /* Pop the spec processing context.  */
5373   argbuf_index = save_argbuf_index;
5374   argbuf_length = save_argbuf_length;
5375   free (argbuf);
5376   argbuf = save_argbuf;
5377
5378   arg_going = save_arg_going;
5379   delete_this_arg = save_delete_this_arg;
5380   this_is_output_file = save_this_is_output_file;
5381   this_is_library_file = save_this_is_library_file;
5382   input_from_pipe = save_input_from_pipe;
5383   suffix_subst = save_suffix_subst;
5384
5385   return funcval;
5386 }
5387
5388 /* Handle a spec function call of the form:
5389
5390    %:function(args)
5391
5392    ARGS is processed as a spec in a separate context and split into an
5393    argument vector in the normal fashion.  The function returns a string
5394    containing a spec which we then process in the caller's context, or
5395    NULL if no processing is required.  */
5396
5397 static const char *
5398 handle_spec_function (const char *p)
5399 {
5400   char *func, *args;
5401   const char *endp, *funcval;
5402   int count;
5403
5404   processing_spec_function++;
5405
5406   /* Get the function name.  */
5407   for (endp = p; *endp != '\0'; endp++)
5408     {
5409       if (*endp == '(')         /* ) */
5410         break;
5411       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5412       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5413         fatal ("malformed spec function name");
5414     }
5415   if (*endp != '(')             /* ) */
5416     fatal ("no arguments for spec function");
5417   func = save_string (p, endp - p);
5418   p = ++endp;
5419
5420   /* Get the arguments.  */
5421   for (count = 0; *endp != '\0'; endp++)
5422     {
5423       /* ( */
5424       if (*endp == ')')
5425         {
5426           if (count == 0)
5427             break;
5428           count--;
5429         }
5430       else if (*endp == '(')    /* ) */
5431         count++;
5432     }
5433   /* ( */
5434   if (*endp != ')')
5435     fatal ("malformed spec function arguments");
5436   args = save_string (p, endp - p);
5437   p = ++endp;
5438
5439   /* p now points to just past the end of the spec function expression.  */
5440
5441   funcval = eval_spec_function (func, args);
5442   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5443     p = NULL;
5444
5445   free (func);
5446   free (args);
5447
5448   processing_spec_function--;
5449
5450   return p;
5451 }
5452
5453 /* Inline subroutine of handle_braces.  Returns true if the current
5454    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5455 static inline bool
5456 input_suffix_matches (const char *atom, const char *end_atom)
5457 {
5458   return (input_suffix
5459           && !strncmp (input_suffix, atom, end_atom - atom)
5460           && input_suffix[end_atom - atom] == '\0');
5461 }
5462
5463 /* Inline subroutine of handle_braces.  Returns true if a switch
5464    matching the atom bracketed by ATOM and END_ATOM appeared on the
5465    command line.  */
5466 static inline bool
5467 switch_matches (const char *atom, const char *end_atom, int starred)
5468 {
5469   int i;
5470   int len = end_atom - atom;
5471   int plen = starred ? len : -1;
5472
5473   for (i = 0; i < n_switches; i++)
5474     if (!strncmp (switches[i].part1, atom, len)
5475         && (starred || switches[i].part1[len] == '\0')
5476         && check_live_switch (i, plen))
5477       return true;
5478
5479   return false;
5480 }
5481
5482 /* Inline subroutine of handle_braces.  Mark all of the switches which
5483    match ATOM (extends to END_ATOM; STARRED indicates whether there
5484    was a star after the atom) for later processing.  */
5485 static inline void
5486 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5487 {
5488   int i;
5489   int len = end_atom - atom;
5490   int plen = starred ? len : -1;
5491
5492   for (i = 0; i < n_switches; i++)
5493     if (!strncmp (switches[i].part1, atom, len)
5494         && (starred || switches[i].part1[len] == '\0')
5495         && check_live_switch (i, plen))
5496       switches[i].ordering = 1;
5497 }
5498
5499 /* Inline subroutine of handle_braces.  Process all the currently
5500    marked switches through give_switch, and clear the marks.  */
5501 static inline void
5502 process_marked_switches (void)
5503 {
5504   int i;
5505
5506   for (i = 0; i < n_switches; i++)
5507     if (switches[i].ordering == 1)
5508       {
5509         switches[i].ordering = 0;
5510         give_switch (i, 0);
5511       }
5512 }
5513
5514 /* Handle a %{ ... } construct.  P points just inside the leading {.
5515    Returns a pointer one past the end of the brace block, or 0
5516    if we call do_spec_1 and that returns -1.  */
5517
5518 static const char *
5519 handle_braces (const char *p)
5520 {
5521   const char *atom, *end_atom;
5522   const char *d_atom = NULL, *d_end_atom = NULL;
5523   const char *orig = p;
5524
5525   bool a_is_suffix;
5526   bool a_is_starred;
5527   bool a_is_negated;
5528   bool a_matched;
5529
5530   bool a_must_be_last = false;
5531   bool ordered_set    = false;
5532   bool disjunct_set   = false;
5533   bool disj_matched   = false;
5534   bool disj_starred   = true;
5535   bool n_way_choice   = false;
5536   bool n_way_matched  = false;
5537
5538 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5539
5540   do
5541     {
5542       if (a_must_be_last)
5543         goto invalid;
5544
5545       /* Scan one "atom" (S in the description above of %{}, possibly
5546          with !, ., or * modifiers).  */
5547       a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5548
5549       SKIP_WHITE();
5550       if (*p == '!')
5551         p++, a_is_negated = true;
5552
5553       SKIP_WHITE();
5554       if (*p == '.')
5555         p++, a_is_suffix = true;
5556
5557       atom = p;
5558       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5559              || *p == ',' || *p == '.' || *p == '@')
5560         p++;
5561       end_atom = p;
5562
5563       if (*p == '*')
5564         p++, a_is_starred = 1;
5565
5566       SKIP_WHITE();
5567       switch (*p)
5568         {
5569         case '&': case '}':
5570           /* Substitute the switch(es) indicated by the current atom.  */
5571           ordered_set = true;
5572           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5573               || atom == end_atom)
5574             goto invalid;
5575
5576           mark_matching_switches (atom, end_atom, a_is_starred);
5577
5578           if (*p == '}')
5579             process_marked_switches ();
5580           break;
5581
5582         case '|': case ':':
5583           /* Substitute some text if the current atom appears as a switch
5584              or suffix.  */
5585           disjunct_set = true;
5586           if (ordered_set)
5587             goto invalid;
5588
5589           if (atom == end_atom)
5590             {
5591               if (!n_way_choice || disj_matched || *p == '|'
5592                   || a_is_negated || a_is_suffix || a_is_starred)
5593                 goto invalid;
5594
5595               /* An empty term may appear as the last choice of an
5596                  N-way choice set; it means "otherwise".  */
5597               a_must_be_last = true;
5598               disj_matched = !n_way_matched;
5599               disj_starred = false;
5600             }
5601           else
5602             {
5603                if (a_is_suffix && a_is_starred)
5604                  goto invalid;
5605
5606                if (!a_is_starred)
5607                  disj_starred = false;
5608
5609                /* Don't bother testing this atom if we already have a
5610                   match.  */
5611                if (!disj_matched && !n_way_matched)
5612                  {
5613                    if (a_is_suffix)
5614                      a_matched = input_suffix_matches (atom, end_atom);
5615                    else
5616                      a_matched = switch_matches (atom, end_atom, a_is_starred);
5617
5618                    if (a_matched != a_is_negated)
5619                      {
5620                        disj_matched = true;
5621                        d_atom = atom;
5622                        d_end_atom = end_atom;
5623                      }
5624                  }
5625             }
5626
5627           if (*p == ':')
5628             {
5629               /* Found the body, that is, the text to substitute if the
5630                  current disjunction matches.  */
5631               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5632                                       disj_matched && !n_way_matched);
5633               if (p == 0)
5634                 return 0;
5635
5636               /* If we have an N-way choice, reset state for the next
5637                  disjunction.  */
5638               if (*p == ';')
5639                 {
5640                   n_way_choice = true;
5641                   n_way_matched |= disj_matched;
5642                   disj_matched = false;
5643                   disj_starred = true;
5644                   d_atom = d_end_atom = NULL;
5645                 }
5646             }
5647           break;
5648
5649         default:
5650           goto invalid;
5651         }
5652     }
5653   while (*p++ != '}');
5654
5655   return p;
5656
5657  invalid:
5658   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
5659
5660 #undef SKIP_WHITE
5661 }
5662
5663 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5664    (X in the description of %{} syntax).  P points one past the colon;
5665    ATOM and END_ATOM bracket the first atom which was found to be true
5666    (present) in the current disjunction; STARRED indicates whether all
5667    the atoms in the current disjunction were starred (for syntax validation);
5668    MATCHED indicates whether the disjunction matched or not, and therefore
5669    whether or not the body is to be processed through do_spec_1 or just
5670    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5671    returns -1.  */
5672
5673 static const char *
5674 process_brace_body (const char *p, const char *atom, const char *end_atom,
5675                     int starred, int matched)
5676 {
5677   const char *body, *end_body;
5678   unsigned int nesting_level;
5679   bool have_subst     = false;
5680
5681   /* Locate the closing } or ;, honoring nested braces.
5682      Trim trailing whitespace.  */
5683   body = p;
5684   nesting_level = 1;
5685   for (;;)
5686     {
5687       if (*p == '{')
5688         nesting_level++;
5689       else if (*p == '}')
5690         {
5691           if (!--nesting_level)
5692             break;
5693         }
5694       else if (*p == ';' && nesting_level == 1)
5695         break;
5696       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5697         have_subst = true;
5698       else if (*p == '\0')
5699         goto invalid;
5700       p++;
5701     }
5702
5703   end_body = p;
5704   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5705     end_body--;
5706
5707   if (have_subst && !starred)
5708     goto invalid;
5709
5710   if (matched)
5711     {
5712       /* Copy the substitution body to permanent storage and execute it.
5713          If have_subst is false, this is a simple matter of running the
5714          body through do_spec_1...  */
5715       char *string = save_string (body, end_body - body);
5716       if (!have_subst)
5717         {
5718           if (do_spec_1 (string, 0, NULL) < 0)
5719             return 0;
5720         }
5721       else
5722         {
5723           /* ... but if have_subst is true, we have to process the
5724              body once for each matching switch, with %* set to the
5725              variant part of the switch.  */
5726           unsigned int hard_match_len = end_atom - atom;
5727           int i;
5728
5729           for (i = 0; i < n_switches; i++)
5730             if (!strncmp (switches[i].part1, atom, hard_match_len)
5731                 && check_live_switch (i, hard_match_len))
5732               {
5733                 if (do_spec_1 (string, 0,
5734                                &switches[i].part1[hard_match_len]) < 0)
5735                   return 0;
5736                 /* Pass any arguments this switch has.  */
5737                 give_switch (i, 1);
5738                 suffix_subst = NULL;
5739               }
5740         }
5741     }
5742
5743   return p;
5744
5745  invalid:
5746   fatal ("braced spec body '%s' is invalid", body);
5747 }
5748 \f
5749 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5750    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5751    spec, or -1 if either exact match or %* is used.
5752
5753    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5754    whose value does not begin with "no-" is obsoleted by the same value
5755    with the "no-", similarly for a switch with the "no-" prefix.  */
5756
5757 static int
5758 check_live_switch (int switchnum, int prefix_length)
5759 {
5760   const char *name = switches[switchnum].part1;
5761   int i;
5762
5763   /* In the common case of {<at-most-one-letter>*}, a negating
5764      switch would always match, so ignore that case.  We will just
5765      send the conflicting switches to the compiler phase.  */
5766   if (prefix_length >= 0 && prefix_length <= 1)
5767     return 1;
5768
5769   /* If we already processed this switch and determined if it was
5770      live or not, return our past determination.  */
5771   if (switches[switchnum].live_cond != 0)
5772     return switches[switchnum].live_cond > 0;
5773
5774   /* Now search for duplicate in a manner that depends on the name.  */
5775   switch (*name)
5776     {
5777     case 'O':
5778       for (i = switchnum + 1; i < n_switches; i++)
5779         if (switches[i].part1[0] == 'O')
5780           {
5781             switches[switchnum].validated = 1;
5782             switches[switchnum].live_cond = SWITCH_FALSE;
5783             return 0;
5784           }
5785       break;
5786
5787     case 'W':  case 'f':  case 'm':
5788       if (! strncmp (name + 1, "no-", 3))
5789         {
5790           /* We have Xno-YYY, search for XYYY.  */
5791           for (i = switchnum + 1; i < n_switches; i++)
5792             if (switches[i].part1[0] == name[0]
5793                 && ! strcmp (&switches[i].part1[1], &name[4]))
5794               {
5795                 switches[switchnum].validated = 1;
5796                 switches[switchnum].live_cond = SWITCH_FALSE;
5797                 return 0;
5798               }
5799         }
5800       else
5801         {
5802           /* We have XYYY, search for Xno-YYY.  */
5803           for (i = switchnum + 1; i < n_switches; i++)
5804             if (switches[i].part1[0] == name[0]
5805                 && switches[i].part1[1] == 'n'
5806                 && switches[i].part1[2] == 'o'
5807                 && switches[i].part1[3] == '-'
5808                 && !strcmp (&switches[i].part1[4], &name[1]))
5809               {
5810                 switches[switchnum].validated = 1;
5811                 switches[switchnum].live_cond = SWITCH_FALSE;
5812                 return 0;
5813               }
5814         }
5815       break;
5816     }
5817
5818   /* Otherwise the switch is live.  */
5819   switches[switchnum].live_cond = SWITCH_LIVE;
5820   return 1;
5821 }
5822 \f
5823 /* Pass a switch to the current accumulating command
5824    in the same form that we received it.
5825    SWITCHNUM identifies the switch; it is an index into
5826    the vector of switches gcc received, which is `switches'.
5827    This cannot fail since it never finishes a command line.
5828
5829    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5830
5831 static void
5832 give_switch (int switchnum, int omit_first_word)
5833 {
5834   if (switches[switchnum].live_cond == SWITCH_IGNORE)
5835     return;
5836
5837   if (!omit_first_word)
5838     {
5839       do_spec_1 ("-", 0, NULL);
5840       do_spec_1 (switches[switchnum].part1, 1, NULL);
5841     }
5842
5843   if (switches[switchnum].args != 0)
5844     {
5845       const char **p;
5846       for (p = switches[switchnum].args; *p; p++)
5847         {
5848           const char *arg = *p;
5849
5850           do_spec_1 (" ", 0, NULL);
5851           if (suffix_subst)
5852             {
5853               unsigned length = strlen (arg);
5854               int dot = 0;
5855
5856               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5857                 if (arg[length] == '.')
5858                   {
5859                     ((char *)arg)[length] = 0;
5860                     dot = 1;
5861                     break;
5862                   }
5863               do_spec_1 (arg, 1, NULL);
5864               if (dot)
5865                 ((char *)arg)[length] = '.';
5866               do_spec_1 (suffix_subst, 1, NULL);
5867             }
5868           else
5869             do_spec_1 (arg, 1, NULL);
5870         }
5871     }
5872
5873   do_spec_1 (" ", 0, NULL);
5874   switches[switchnum].validated = 1;
5875 }
5876 \f
5877 /* Search for a file named NAME trying various prefixes including the
5878    user's -B prefix and some standard ones.
5879    Return the absolute file name found.  If nothing is found, return NAME.  */
5880
5881 static const char *
5882 find_file (const char *name)
5883 {
5884   char *newname;
5885
5886   /* Try multilib_dir if it is defined.  */
5887   if (multilib_os_dir != NULL)
5888     {
5889       newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
5890
5891       /* If we don't find it in the multi library dir, then fall
5892          through and look for it in the normal places.  */
5893       if (newname != NULL)
5894         return newname;
5895     }
5896
5897   newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
5898   return newname ? newname : name;
5899 }
5900
5901 /* Determine whether a directory exists.  If LINKER, return 0 for
5902    certain fixed names not needed by the linker.  If not LINKER, it is
5903    only important to return 0 if the host machine has a small ARG_MAX
5904    limit.  */
5905
5906 static int
5907 is_directory (const char *path1, const char *path2, int linker)
5908 {
5909   int len1 = strlen (path1);
5910   int len2 = strlen (path2);
5911   char *path = alloca (3 + len1 + len2);
5912   char *cp;
5913   struct stat st;
5914
5915 #ifndef SMALL_ARG_MAX
5916   if (! linker)
5917     return 1;
5918 #endif
5919
5920   /* Construct the path from the two parts.  Ensure the string ends with "/.".
5921      The resulting path will be a directory even if the given path is a
5922      symbolic link.  */
5923   memcpy (path, path1, len1);
5924   memcpy (path + len1, path2, len2);
5925   cp = path + len1 + len2;
5926   if (!IS_DIR_SEPARATOR (cp[-1]))
5927     *cp++ = DIR_SEPARATOR;
5928   *cp++ = '.';
5929   *cp = '\0';
5930
5931   /* Exclude directories that the linker is known to search.  */
5932   if (linker
5933       && ((cp - path == 6
5934            && strcmp (path, concat (dir_separator_str, "lib",
5935                                     dir_separator_str, ".", NULL)) == 0)
5936           || (cp - path == 10
5937               && strcmp (path, concat (dir_separator_str, "usr",
5938                                        dir_separator_str, "lib",
5939                                        dir_separator_str, ".", NULL)) == 0)))
5940     return 0;
5941
5942   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5943 }
5944
5945 /* Set up the various global variables to indicate that we're processing
5946    the input file named FILENAME.  */
5947
5948 void
5949 set_input (const char *filename)
5950 {
5951   const char *p;
5952
5953   input_filename = filename;
5954   input_filename_length = strlen (input_filename);
5955
5956   input_basename = input_filename;
5957 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5958   /* Skip drive name so 'x:foo' is handled properly.  */
5959   if (input_basename[1] == ':')
5960     input_basename += 2;
5961 #endif
5962   for (p = input_basename; *p; p++)
5963     if (IS_DIR_SEPARATOR (*p))
5964       input_basename = p + 1;
5965
5966   /* Find a suffix starting with the last period,
5967      and set basename_length to exclude that suffix.  */
5968   basename_length = strlen (input_basename);
5969   suffixed_basename_length = basename_length;
5970   p = input_basename + basename_length;
5971   while (p != input_basename && *p != '.')
5972     --p;
5973   if (*p == '.' && p != input_basename)
5974     {
5975       basename_length = p - input_basename;
5976       input_suffix = p + 1;
5977     }
5978   else
5979     input_suffix = "";
5980
5981   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5982      we will need to do a stat on the input_filename.  The
5983      INPUT_STAT_SET signals that the stat is needed.  */
5984   input_stat_set = 0;
5985 }
5986 \f
5987 /* On fatal signals, delete all the temporary files.  */
5988
5989 static void
5990 fatal_error (int signum)
5991 {
5992   signal (signum, SIG_DFL);
5993   delete_failure_queue ();
5994   delete_temp_files ();
5995   /* Get the same signal again, this time not handled,
5996      so its normal effect occurs.  */
5997   kill (getpid (), signum);
5998 }
5999
6000 extern int main (int, const char **);
6001
6002 int
6003 main (int argc, const char **argv)
6004 {
6005   size_t i;
6006   int value;
6007   int linker_was_run = 0;
6008   int lang_n_infiles = 0;
6009   int num_linker_inputs = 0;
6010   char *explicit_link_files;
6011   char *specs_file;
6012   const char *p;
6013   struct user_specs *uptr;
6014
6015   p = argv[0] + strlen (argv[0]);
6016   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6017     --p;
6018   programname = p;
6019
6020   xmalloc_set_program_name (programname);
6021
6022 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6023   /* Perform host dependent initialization when needed.  */
6024   GCC_DRIVER_HOST_INITIALIZATION;
6025 #endif
6026
6027   gcc_init_libintl ();
6028
6029   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6030     signal (SIGINT, fatal_error);
6031 #ifdef SIGHUP
6032   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6033     signal (SIGHUP, fatal_error);
6034 #endif
6035   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6036     signal (SIGTERM, fatal_error);
6037 #ifdef SIGPIPE
6038   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6039     signal (SIGPIPE, fatal_error);
6040 #endif
6041 #ifdef SIGCHLD
6042   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6043      receive the signal.  A different setting is inheritable */
6044   signal (SIGCHLD, SIG_DFL);
6045 #endif
6046
6047   /* Allocate the argument vector.  */
6048   alloc_args ();
6049
6050   obstack_init (&obstack);
6051
6052   /* Build multilib_select, et. al from the separate lines that make up each
6053      multilib selection.  */
6054   {
6055     const char *const *q = multilib_raw;
6056     int need_space;
6057
6058     obstack_init (&multilib_obstack);
6059     while ((p = *q++) != (char *) 0)
6060       obstack_grow (&multilib_obstack, p, strlen (p));
6061
6062     obstack_1grow (&multilib_obstack, 0);
6063     multilib_select = obstack_finish (&multilib_obstack);
6064
6065     q = multilib_matches_raw;
6066     while ((p = *q++) != (char *) 0)
6067       obstack_grow (&multilib_obstack, p, strlen (p));
6068
6069     obstack_1grow (&multilib_obstack, 0);
6070     multilib_matches = obstack_finish (&multilib_obstack);
6071
6072     q = multilib_exclusions_raw;
6073     while ((p = *q++) != (char *) 0)
6074       obstack_grow (&multilib_obstack, p, strlen (p));
6075
6076     obstack_1grow (&multilib_obstack, 0);
6077     multilib_exclusions = obstack_finish (&multilib_obstack);
6078
6079     need_space = FALSE;
6080     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6081       {
6082         if (need_space)
6083           obstack_1grow (&multilib_obstack, ' ');
6084         obstack_grow (&multilib_obstack,
6085                       multilib_defaults_raw[i],
6086                       strlen (multilib_defaults_raw[i]));
6087         need_space = TRUE;
6088       }
6089
6090     obstack_1grow (&multilib_obstack, 0);
6091     multilib_defaults = obstack_finish (&multilib_obstack);
6092   }
6093
6094   /* Set up to remember the pathname of gcc and any options
6095      needed for collect.  We use argv[0] instead of programname because
6096      we need the complete pathname.  */
6097   obstack_init (&collect_obstack);
6098   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6099   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6100   putenv (obstack_finish (&collect_obstack));
6101
6102 #ifdef INIT_ENVIRONMENT
6103   /* Set up any other necessary machine specific environment variables.  */
6104   putenv (INIT_ENVIRONMENT);
6105 #endif
6106
6107   /* Make a table of what switches there are (switches, n_switches).
6108      Make a table of specified input files (infiles, n_infiles).
6109      Decode switches that are handled locally.  */
6110
6111   process_command (argc, argv);
6112
6113   /* Initialize the vector of specs to just the default.
6114      This means one element containing 0s, as a terminator.  */
6115
6116   compilers = xmalloc (sizeof default_compilers);
6117   memcpy (compilers, default_compilers, sizeof default_compilers);
6118   n_compilers = n_default_compilers;
6119
6120   /* Read specs from a file if there is one.  */
6121
6122   machine_suffix = concat (spec_machine, dir_separator_str,
6123                            spec_version, dir_separator_str, NULL);
6124   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6125
6126   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
6127   /* Read the specs file unless it is a default one.  */
6128   if (specs_file != 0 && strcmp (specs_file, "specs"))
6129     read_specs (specs_file, TRUE);
6130   else
6131     init_spec ();
6132
6133   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6134      for any override of as, ld and libraries.  */
6135   specs_file = alloca (strlen (standard_exec_prefix)
6136                        + strlen (just_machine_suffix) + sizeof ("specs"));
6137
6138   strcpy (specs_file, standard_exec_prefix);
6139   strcat (specs_file, just_machine_suffix);
6140   strcat (specs_file, "specs");
6141   if (access (specs_file, R_OK) == 0)
6142     read_specs (specs_file, TRUE);
6143
6144   /* Process any configure-time defaults specified for the command line
6145      options, via OPTION_DEFAULT_SPECS.  */
6146   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6147     do_option_spec (option_default_specs[i].name,
6148                     option_default_specs[i].spec);
6149
6150   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6151      of the command line.  */
6152
6153   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6154     do_self_spec (driver_self_specs[i]);
6155
6156   /* If not cross-compiling, look for executables in the standard
6157      places.  */
6158   if (*cross_compile == '0')
6159     {
6160       if (*md_exec_prefix)
6161         {
6162           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6163                       PREFIX_PRIORITY_LAST, 0, 0);
6164         }
6165     }
6166
6167   /* Process sysroot_suffix_spec.  */
6168   if (*sysroot_suffix_spec != 0
6169       && do_spec_2 (sysroot_suffix_spec) == 0)
6170     {
6171       if (argbuf_index > 1)
6172         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC.");
6173       else if (argbuf_index == 1)
6174         target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6175     }
6176
6177   /* Process sysroot_hdrs_suffix_spec.  */
6178   if (*sysroot_hdrs_suffix_spec != 0
6179       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6180     {
6181       if (argbuf_index > 1)
6182         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC.");
6183       else if (argbuf_index == 1)
6184         target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6185     }
6186
6187   /* Look for startfiles in the standard places.  */
6188   if (*startfile_prefix_spec != 0
6189       && do_spec_2 (startfile_prefix_spec) == 0
6190       && do_spec_1 (" ", 0, NULL) == 0)
6191     {
6192       int ndx;
6193       for (ndx = 0; ndx < argbuf_index; ndx++)
6194         add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6195                               PREFIX_PRIORITY_LAST, 0, 1);
6196     }
6197   /* We should eventually get rid of all these and stick to
6198      startfile_prefix_spec exclusively.  */
6199   else if (*cross_compile == '0' || target_system_root)
6200     {
6201       if (*md_exec_prefix)
6202         add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
6203                               PREFIX_PRIORITY_LAST, 0, 1);
6204
6205       if (*md_startfile_prefix)
6206         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6207                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6208
6209       if (*md_startfile_prefix_1)
6210         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6211                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6212
6213       /* If standard_startfile_prefix is relative, base it on
6214          standard_exec_prefix.  This lets us move the installed tree
6215          as a unit.  If GCC_EXEC_PREFIX is defined, base
6216          standard_startfile_prefix on that as well.
6217
6218          If the prefix is relative, only search it for native compilers;
6219          otherwise we will search a directory containing host libraries.  */
6220       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6221         add_sysrooted_prefix (&startfile_prefixes,
6222                               standard_startfile_prefix, "BINUTILS",
6223                               PREFIX_PRIORITY_LAST, 0, 1);
6224       else if (*cross_compile == '0')
6225         {
6226           if (gcc_exec_prefix)
6227             add_prefix (&startfile_prefixes,
6228                         concat (gcc_exec_prefix, machine_suffix,
6229                                 standard_startfile_prefix, NULL),
6230                         NULL, PREFIX_PRIORITY_LAST, 0, 1);
6231           add_prefix (&startfile_prefixes,
6232                       concat (standard_exec_prefix,
6233                               machine_suffix,
6234                               standard_startfile_prefix, NULL),
6235                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6236         }
6237
6238       if (*standard_startfile_prefix_1)
6239         add_sysrooted_prefix (&startfile_prefixes,
6240                               standard_startfile_prefix_1, "BINUTILS",
6241                               PREFIX_PRIORITY_LAST, 0, 1);
6242       if (*standard_startfile_prefix_2)
6243         add_sysrooted_prefix (&startfile_prefixes,
6244                               standard_startfile_prefix_2, "BINUTILS",
6245                               PREFIX_PRIORITY_LAST, 0, 1);
6246     }
6247
6248   /* Process any user specified specs in the order given on the command
6249      line.  */
6250   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6251     {
6252       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6253                                     R_OK, 0);
6254       read_specs (filename ? filename : uptr->filename, FALSE);
6255     }
6256
6257   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6258   if (gcc_exec_prefix)
6259     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6260                               spec_version, dir_separator_str, NULL);
6261
6262   /* Now we have the specs.
6263      Set the `valid' bits for switches that match anything in any spec.  */
6264
6265   validate_all_switches ();
6266
6267   /* Now that we have the switches and the specs, set
6268      the subdirectory based on the options.  */
6269   set_multilib_dir ();
6270
6271   /* Warn about any switches that no pass was interested in.  */
6272
6273   for (i = 0; (int) i < n_switches; i++)
6274     if (! switches[i].validated)
6275       error ("unrecognized option '-%s'", switches[i].part1);
6276
6277   /* Obey some of the options.  */
6278
6279   if (print_search_dirs)
6280     {
6281       printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6282       printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6283       printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6284       return (0);
6285     }
6286
6287   if (print_file_name)
6288     {
6289       printf ("%s\n", find_file (print_file_name));
6290       return (0);
6291     }
6292
6293   if (print_prog_name)
6294     {
6295       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6296       printf ("%s\n", (newname ? newname : print_prog_name));
6297       return (0);
6298     }
6299
6300   if (print_multi_lib)
6301     {
6302       print_multilib_info ();
6303       return (0);
6304     }
6305
6306   if (print_multi_directory)
6307     {
6308       if (multilib_dir == NULL)
6309         printf (".\n");
6310       else
6311         printf ("%s\n", multilib_dir);
6312       return (0);
6313     }
6314
6315   if (print_multi_os_directory)
6316     {
6317       if (multilib_os_dir == NULL)
6318         printf (".\n");
6319       else
6320         printf ("%s\n", multilib_os_dir);
6321       return (0);
6322     }
6323
6324   if (target_help_flag)
6325    {
6326       /* Print if any target specific options.  */
6327
6328       /* We do not exit here. Instead we have created a fake input file
6329          called 'target-dummy' which needs to be compiled, and we pass this
6330          on to the various sub-processes, along with the --target-help
6331          switch.  */
6332     }
6333
6334   if (print_help_list)
6335     {
6336       display_help ();
6337
6338       if (! verbose_flag)
6339         {
6340           printf (_("\nFor bug reporting instructions, please see:\n"));
6341           printf ("%s.\n", bug_report_url);
6342
6343           return (0);
6344         }
6345
6346       /* We do not exit here.  Instead we have created a fake input file
6347          called 'help-dummy' which needs to be compiled, and we pass this
6348          on the various sub-processes, along with the --help switch.  */
6349     }
6350
6351   if (verbose_flag)
6352     {
6353       int n;
6354       const char *thrmod;
6355
6356       notice ("Configured with: %s\n", configuration_arguments);
6357
6358 #ifdef THREAD_MODEL_SPEC
6359       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6360          but there's no point in doing all this processing just to get
6361          thread_model back.  */
6362       obstack_init (&obstack);
6363       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6364       obstack_1grow (&obstack, '\0');
6365       thrmod = obstack_finish (&obstack);
6366 #else
6367       thrmod = thread_model;
6368 #endif
6369
6370       notice ("Thread model: %s\n", thrmod);
6371
6372       /* compiler_version is truncated at the first space when initialized
6373          from version string, so truncate version_string at the first space
6374          before comparing.  */
6375       for (n = 0; version_string[n]; n++)
6376         if (version_string[n] == ' ')
6377           break;
6378
6379       if (! strncmp (version_string, compiler_version, n)
6380           && compiler_version[n] == 0)
6381         notice ("gcc version %s\n", version_string);
6382       else
6383         notice ("gcc driver version %s executing gcc version %s\n",
6384                 version_string, compiler_version);
6385
6386       if (n_infiles == 0)
6387         return (0);
6388     }
6389
6390   if (n_infiles == added_libraries)
6391     fatal ("no input files");
6392
6393   /* Make a place to record the compiler output file names
6394      that correspond to the input files.  */
6395
6396   i = n_infiles;
6397   i += lang_specific_extra_outfiles;
6398   outfiles = xcalloc (i, sizeof (char *));
6399
6400   /* Record which files were specified explicitly as link input.  */
6401
6402   explicit_link_files = xcalloc (1, n_infiles);
6403
6404   if (combine_flag)
6405     combine_inputs = true;
6406   else
6407     combine_inputs = false;
6408
6409   for (i = 0; (int) i < n_infiles; i++)
6410     {
6411       const char *name = infiles[i].name;
6412       struct compiler *compiler = lookup_compiler (name,
6413                                                    strlen (name),
6414                                                    infiles[i].language);
6415
6416       if (compiler && !(compiler->combinable))
6417         combine_inputs = false;
6418
6419       if (lang_n_infiles > 0 && compiler != input_file_compiler
6420           && infiles[i].language && infiles[i].language[0] != '*')
6421         infiles[i].incompiler = compiler;
6422       else if (compiler)
6423         {
6424           lang_n_infiles++;
6425           input_file_compiler = compiler;
6426           infiles[i].incompiler = compiler;
6427         }
6428       else
6429         {
6430           /* Since there is no compiler for this input file, assume it is a
6431              linker file.  */
6432           explicit_link_files[i] = 1;
6433           infiles[i].incompiler = NULL;
6434         }
6435       infiles[i].compiled = false;
6436       infiles[i].preprocessed = false;
6437     }
6438
6439   if (combine_flag && save_temps_flag)
6440     {
6441       bool save_combine_inputs = combine_inputs;
6442       /* Must do a separate pre-processing pass for C & Objective-C files, to
6443          obtain individual .i files.  */
6444
6445       combine_inputs = false;
6446       for (i = 0; (int) i < n_infiles; i++)
6447         {
6448           int this_file_error = 0;
6449
6450           input_file_number = i;
6451           set_input (infiles[i].name);
6452           if (infiles[i].incompiler
6453               && (infiles[i].incompiler)->needs_preprocessing)
6454             input_file_compiler = infiles[i].incompiler;
6455           else
6456             continue;
6457
6458           if (input_file_compiler)
6459             {
6460               if (input_file_compiler->spec[0] == '#')
6461                 {
6462                   error ("%s: %s compiler not installed on this system",
6463                          input_filename, &input_file_compiler->spec[1]);
6464                   this_file_error = 1;
6465                 }
6466               else
6467                 {
6468                   value = do_spec (input_file_compiler->spec);
6469                   infiles[i].preprocessed = true;
6470                   if (!have_o_argbuf_index)
6471                     fatal ("spec '%s' is invalid", input_file_compiler->spec);
6472                   infiles[i].name = argbuf[have_o_argbuf_index];
6473                   infiles[i].incompiler
6474                     = lookup_compiler (infiles[i].name,
6475                                        strlen (infiles[i].name),
6476                                        infiles[i].language);
6477
6478                   if (value < 0)
6479                     this_file_error = 1;
6480                 }
6481             }
6482
6483           if (this_file_error)
6484             {
6485               delete_failure_queue ();
6486               error_count++;
6487               break;
6488             }
6489           clear_failure_queue ();
6490         }
6491       combine_inputs = save_combine_inputs;
6492     }
6493
6494   for (i = 0; (int) i < n_infiles; i++)
6495     {
6496       int this_file_error = 0;
6497
6498       /* Tell do_spec what to substitute for %i.  */
6499
6500       input_file_number = i;
6501       set_input (infiles[i].name);
6502
6503       if (infiles[i].compiled)
6504         continue;
6505
6506       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6507
6508       outfiles[i] = input_filename;
6509
6510       /* Figure out which compiler from the file's suffix.  */
6511
6512       if (! combine_inputs)
6513         input_file_compiler
6514           = lookup_compiler (infiles[i].name, input_filename_length,
6515                              infiles[i].language);
6516       else
6517         input_file_compiler = infiles[i].incompiler;
6518
6519       if (input_file_compiler)
6520         {
6521           /* Ok, we found an applicable compiler.  Run its spec.  */
6522
6523           if (input_file_compiler->spec[0] == '#')
6524             {
6525               error ("%s: %s compiler not installed on this system",
6526                      input_filename, &input_file_compiler->spec[1]);
6527               this_file_error = 1;
6528             }
6529           else
6530             {
6531               value = do_spec (input_file_compiler->spec);
6532               infiles[i].compiled = true;
6533               if (value < 0)
6534                 this_file_error = 1;
6535             }
6536         }
6537
6538       /* If this file's name does not contain a recognized suffix,
6539          record it as explicit linker input.  */
6540
6541       else
6542         explicit_link_files[i] = 1;
6543
6544       /* Clear the delete-on-failure queue, deleting the files in it
6545          if this compilation failed.  */
6546
6547       if (this_file_error)
6548         {
6549           delete_failure_queue ();
6550           error_count++;
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