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