gcc/gcc.c

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