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