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