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 (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   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
1723      on ?: in file-scope variable initializations.  */
1724   asm_debug = ASM_DEBUG_SPEC;
1725
1726   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1727     {
1728       sl = &static_specs[i];
1729       sl->next = next;
1730       next = sl;
1731     }
1732
1733 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1734   /* ??? If neither -shared-libgcc nor --static-libgcc was
1735      seen, then we should be making an educated guess.  Some proposed
1736      heuristics for ELF include:
1737
1738         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1739             program will be doing dynamic loading, which will likely
1740             need the shared libgcc.
1741
1742         (2) If "-ldl", then it's also a fair bet that we're doing
1743             dynamic loading.
1744
1745         (3) For each ET_DYN we're linking against (either through -lfoo
1746             or /some/path/foo.so), check to see whether it or one of
1747             its dependencies depends on a shared libgcc.
1748
1749         (4) If "-shared"
1750
1751             If the runtime is fixed to look for program headers instead
1752             of calling __register_frame_info at all, for each object,
1753             use the shared libgcc if any EH symbol referenced.
1754
1755             If crtstuff is fixed to not invoke __register_frame_info
1756             automatically, for each object, use the shared libgcc if
1757             any non-empty unwind section found.
1758
1759      Doing any of this probably requires invoking an external program to
1760      do the actual object file scanning.  */
1761   {
1762     const char *p = libgcc_spec;
1763     int in_sep = 1;
1764
1765     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1766        when given the proper command line arguments.  */
1767     while (*p)
1768       {
1769         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1770           {
1771             init_gcc_specs (&obstack,
1772                             "-lgcc_s"
1773 #ifdef USE_LIBUNWIND_EXCEPTIONS
1774                             " -lunwind"
1775 #endif
1776                             ,
1777                             "-lgcc",
1778                             "-lgcc_eh"
1779 #ifdef USE_LIBUNWIND_EXCEPTIONS
1780 # ifdef HAVE_LD_STATIC_DYNAMIC
1781                             " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1782 # else
1783                             " -lunwind"
1784 # endif
1785 #endif
1786                             );
1787
1788             p += 5;
1789             in_sep = 0;
1790           }
1791         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1792           {
1793             /* Ug.  We don't know shared library extensions.  Hope that
1794                systems that use this form don't do shared libraries.  */
1795             init_gcc_specs (&obstack,
1796                             "-lgcc_s",
1797                             "libgcc.a%s",
1798                             "libgcc_eh.a%s"
1799 #ifdef USE_LIBUNWIND_EXCEPTIONS
1800                             " -lunwind"
1801 #endif
1802                             );
1803             p += 10;
1804             in_sep = 0;
1805           }
1806         else
1807           {
1808             obstack_1grow (&obstack, *p);
1809             in_sep = (*p == ' ');
1810             p += 1;
1811           }
1812       }
1813
1814     obstack_1grow (&obstack, '\0');
1815     libgcc_spec = XOBFINISH (&obstack, const char *);
1816   }
1817 #endif
1818 #ifdef USE_AS_TRADITIONAL_FORMAT
1819   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1820   {
1821     static const char tf[] = "--traditional-format ";
1822     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1823     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1824     asm_spec = XOBFINISH (&obstack, const char *);
1825   }
1826 #endif
1827 #ifdef LINK_EH_SPEC
1828   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1829   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1830   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1831   link_spec = XOBFINISH (&obstack, const char *);
1832 #endif
1833
1834   specs = sl;
1835 }
1836 \f
1837 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1838    removed; If the spec starts with a + then SPEC is added to the end of the
1839    current spec.  */
1840
1841 static void
1842 set_spec (const char *name, const char *spec)
1843 {
1844   struct spec_list *sl;
1845   const char *old_spec;
1846   int name_len = strlen (name);
1847   int i;
1848
1849   /* If this is the first call, initialize the statically allocated specs.  */
1850   if (!specs)
1851     {
1852       struct spec_list *next = (struct spec_list *) 0;
1853       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1854         {
1855           sl = &static_specs[i];
1856           sl->next = next;
1857           next = sl;
1858         }
1859       specs = sl;
1860     }
1861
1862   /* See if the spec already exists.  */
1863   for (sl = specs; sl; sl = sl->next)
1864     if (name_len == sl->name_len && !strcmp (sl->name, name))
1865       break;
1866
1867   if (!sl)
1868     {
1869       /* Not found - make it.  */
1870       sl = XNEW (struct spec_list);
1871       sl->name = xstrdup (name);
1872       sl->name_len = name_len;
1873       sl->ptr_spec = &sl->ptr;
1874       sl->alloc_p = 0;
1875       *(sl->ptr_spec) = "";
1876       sl->next = specs;
1877       specs = sl;
1878     }
1879
1880   old_spec = *(sl->ptr_spec);
1881   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1882                      ? concat (old_spec, spec + 1, NULL)
1883                      : xstrdup (spec));
1884
1885 #ifdef DEBUG_SPECS
1886   if (verbose_flag)
1887     notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1888 #endif
1889
1890   /* Free the old spec.  */
1891   if (old_spec && sl->alloc_p)
1892     free (CONST_CAST(char *, old_spec));
1893
1894   sl->alloc_p = 1;
1895 }
1896 \f
1897 /* Accumulate a command (program name and args), and run it.  */
1898
1899 /* Vector of pointers to arguments in the current line of specifications.  */
1900
1901 static const char **argbuf;
1902
1903 /* Number of elements allocated in argbuf.  */
1904
1905 static int argbuf_length;
1906
1907 /* Number of elements in argbuf currently in use (containing args).  */
1908
1909 static int argbuf_index;
1910
1911 /* Position in the argbuf array containing the name of the output file
1912    (the value associated with the "-o" flag).  */
1913
1914 static int have_o_argbuf_index = 0;
1915
1916 /* Were the options -c or -S passed.  */
1917 static int have_c = 0;
1918
1919 /* Was the option -o passed.  */
1920 static int have_o = 0;
1921
1922 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1923    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1924    it here.  */
1925
1926 static struct temp_name {
1927   const char *suffix;   /* suffix associated with the code.  */
1928   int length;           /* strlen (suffix).  */
1929   int unique;           /* Indicates whether %g or %u/%U was used.  */
1930   const char *filename; /* associated filename.  */
1931   int filename_length;  /* strlen (filename).  */
1932   struct temp_name *next;
1933 } *temp_names;
1934
1935 /* Number of commands executed so far.  */
1936
1937 static int execution_count;
1938
1939 /* Number of commands that exited with a signal.  */
1940
1941 static int signal_count;
1942
1943 /* Name with which this program was invoked.  */
1944
1945 static const char *programname;
1946 \f
1947 /* Allocate the argument vector.  */
1948
1949 static void
1950 alloc_args (void)
1951 {
1952   argbuf_length = 10;
1953   argbuf = XNEWVEC (const char *, argbuf_length);
1954 }
1955
1956 /* Clear out the vector of arguments (after a command is executed).  */
1957
1958 static void
1959 clear_args (void)
1960 {
1961   argbuf_index = 0;
1962 }
1963
1964 /* Add one argument to the vector at the end.
1965    This is done when a space is seen or at the end of the line.
1966    If DELETE_ALWAYS is nonzero, the arg is a filename
1967     and the file should be deleted eventually.
1968    If DELETE_FAILURE is nonzero, the arg is a filename
1969     and the file should be deleted if this compilation fails.  */
1970
1971 static void
1972 store_arg (const char *arg, int delete_always, int delete_failure)
1973 {
1974   if (argbuf_index + 1 == argbuf_length)
1975     argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1976
1977   argbuf[argbuf_index++] = arg;
1978   argbuf[argbuf_index] = 0;
1979
1980   if (strcmp (arg, "-o") == 0)
1981     have_o_argbuf_index = argbuf_index;
1982   if (delete_always || delete_failure)
1983     record_temp_file (arg, delete_always, delete_failure);
1984 }
1985 \f
1986 /* Load specs from a file name named FILENAME, replacing occurrences of
1987    various different types of line-endings, \r\n, \n\r and just \r, with
1988    a single \n.  */
1989
1990 static char *
1991 load_specs (const char *filename)
1992 {
1993   int desc;
1994   int readlen;
1995   struct stat statbuf;
1996   char *buffer;
1997   char *buffer_p;
1998   char *specs;
1999   char *specs_p;
2000
2001   if (verbose_flag)
2002     notice ("Reading specs from %s\n", filename);
2003
2004   /* Open and stat the file.  */
2005   desc = open (filename, O_RDONLY, 0);
2006   if (desc < 0)
2007     pfatal_with_name (filename);
2008   if (stat (filename, &statbuf) < 0)
2009     pfatal_with_name (filename);
2010
2011   /* Read contents of file into BUFFER.  */
2012   buffer = XNEWVEC (char, statbuf.st_size + 1);
2013   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2014   if (readlen < 0)
2015     pfatal_with_name (filename);
2016   buffer[readlen] = 0;
2017   close (desc);
2018
2019   specs = XNEWVEC (char, readlen + 1);
2020   specs_p = specs;
2021   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2022     {
2023       int skip = 0;
2024       char c = *buffer_p;
2025       if (c == '\r')
2026         {
2027           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
2028             skip = 1;
2029           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
2030             skip = 1;
2031           else                                                  /* \r */
2032             c = '\n';
2033         }
2034       if (! skip)
2035         *specs_p++ = c;
2036     }
2037   *specs_p = '\0';
2038
2039   free (buffer);
2040   return (specs);
2041 }
2042
2043 /* Read compilation specs from a file named FILENAME,
2044    replacing the default ones.
2045
2046    A suffix which starts with `*' is a definition for
2047    one of the machine-specific sub-specs.  The "suffix" should be
2048    *asm, *cc1, *cpp, *link, *startfile, etc.
2049    The corresponding spec is stored in asm_spec, etc.,
2050    rather than in the `compilers' vector.
2051
2052    Anything invalid in the file is a fatal error.  */
2053
2054 static void
2055 read_specs (const char *filename, int main_p)
2056 {
2057   char *buffer;
2058   char *p;
2059
2060   buffer = load_specs (filename);
2061
2062   /* Scan BUFFER for specs, putting them in the vector.  */
2063   p = buffer;
2064   while (1)
2065     {
2066       char *suffix;
2067       char *spec;
2068       char *in, *out, *p1, *p2, *p3;
2069
2070       /* Advance P in BUFFER to the next nonblank nocomment line.  */
2071       p = skip_whitespace (p);
2072       if (*p == 0)
2073         break;
2074
2075       /* Is this a special command that starts with '%'? */
2076       /* Don't allow this for the main specs file, since it would
2077          encourage people to overwrite it.  */
2078       if (*p == '%' && !main_p)
2079         {
2080           p1 = p;
2081           while (*p && *p != '\n')
2082             p++;
2083
2084           /* Skip '\n'.  */
2085           p++;
2086
2087           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2088               && (p1[sizeof "%include" - 1] == ' '
2089                   || p1[sizeof "%include" - 1] == '\t'))
2090             {
2091               char *new_filename;
2092
2093               p1 += sizeof ("%include");
2094               while (*p1 == ' ' || *p1 == '\t')
2095                 p1++;
2096
2097               if (*p1++ != '<' || p[-2] != '>')
2098                 fatal ("specs %%include syntax malformed after %ld characters",
2099                        (long) (p1 - buffer + 1));
2100
2101               p[-2] = '\0';
2102               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2103               read_specs (new_filename ? new_filename : p1, FALSE);
2104               continue;
2105             }
2106           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2107                    && (p1[sizeof "%include_noerr" - 1] == ' '
2108                        || p1[sizeof "%include_noerr" - 1] == '\t'))
2109             {
2110               char *new_filename;
2111
2112               p1 += sizeof "%include_noerr";
2113               while (*p1 == ' ' || *p1 == '\t')
2114                 p1++;
2115
2116               if (*p1++ != '<' || p[-2] != '>')
2117                 fatal ("specs %%include syntax malformed after %ld characters",
2118                        (long) (p1 - buffer + 1));
2119
2120               p[-2] = '\0';
2121               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2122               if (new_filename)
2123                 read_specs (new_filename, FALSE);
2124               else if (verbose_flag)
2125                 notice ("could not find specs file %s\n", p1);
2126               continue;
2127             }
2128           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2129                    && (p1[sizeof "%rename" - 1] == ' '
2130                        || p1[sizeof "%rename" - 1] == '\t'))
2131             {
2132               int name_len;
2133               struct spec_list *sl;
2134               struct spec_list *newsl;
2135
2136               /* Get original name.  */
2137               p1 += sizeof "%rename";
2138               while (*p1 == ' ' || *p1 == '\t')
2139                 p1++;
2140
2141               if (! ISALPHA ((unsigned char) *p1))
2142                 fatal ("specs %%rename syntax malformed after %ld characters",
2143                        (long) (p1 - buffer));
2144
2145               p2 = p1;
2146               while (*p2 && !ISSPACE ((unsigned char) *p2))
2147                 p2++;
2148
2149               if (*p2 != ' ' && *p2 != '\t')
2150                 fatal ("specs %%rename syntax malformed after %ld characters",
2151                        (long) (p2 - buffer));
2152
2153               name_len = p2 - p1;
2154               *p2++ = '\0';
2155               while (*p2 == ' ' || *p2 == '\t')
2156                 p2++;
2157
2158               if (! ISALPHA ((unsigned char) *p2))
2159                 fatal ("specs %%rename syntax malformed after %ld characters",
2160                        (long) (p2 - buffer));
2161
2162               /* Get new spec name.  */
2163               p3 = p2;
2164               while (*p3 && !ISSPACE ((unsigned char) *p3))
2165                 p3++;
2166
2167               if (p3 != p - 1)
2168                 fatal ("specs %%rename syntax malformed after %ld characters",
2169                        (long) (p3 - buffer));
2170               *p3 = '\0';
2171
2172               for (sl = specs; sl; sl = sl->next)
2173                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2174                   break;
2175
2176               if (!sl)
2177                 fatal ("specs %s spec was not found to be renamed", p1);
2178
2179               if (strcmp (p1, p2) == 0)
2180                 continue;
2181
2182               for (newsl = specs; newsl; newsl = newsl->next)
2183                 if (strcmp (newsl->name, p2) == 0)
2184                   fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2185                     filename, p1, p2);
2186
2187               if (verbose_flag)
2188                 {
2189                   notice ("rename spec %s to %s\n", p1, p2);
2190 #ifdef DEBUG_SPECS
2191                   notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2192 #endif
2193                 }
2194
2195               set_spec (p2, *(sl->ptr_spec));
2196               if (sl->alloc_p)
2197                 free (CONST_CAST (char *, *(sl->ptr_spec)));
2198
2199               *(sl->ptr_spec) = "";
2200               sl->alloc_p = 0;
2201               continue;
2202             }
2203           else
2204             fatal ("specs unknown %% command after %ld characters",
2205                    (long) (p1 - buffer));
2206         }
2207
2208       /* Find the colon that should end the suffix.  */
2209       p1 = p;
2210       while (*p1 && *p1 != ':' && *p1 != '\n')
2211         p1++;
2212
2213       /* The colon shouldn't be missing.  */
2214       if (*p1 != ':')
2215         fatal ("specs file malformed after %ld characters",
2216                (long) (p1 - buffer));
2217
2218       /* Skip back over trailing whitespace.  */
2219       p2 = p1;
2220       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2221         p2--;
2222
2223       /* Copy the suffix to a string.  */
2224       suffix = save_string (p, p2 - p);
2225       /* Find the next line.  */
2226       p = skip_whitespace (p1 + 1);
2227       if (p[1] == 0)
2228         fatal ("specs file malformed after %ld characters",
2229                (long) (p - buffer));
2230
2231       p1 = p;
2232       /* Find next blank line or end of string.  */
2233       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2234         p1++;
2235
2236       /* Specs end at the blank line and do not include the newline.  */
2237       spec = save_string (p, p1 - p);
2238       p = p1;
2239
2240       /* Delete backslash-newline sequences from the spec.  */
2241       in = spec;
2242       out = spec;
2243       while (*in != 0)
2244         {
2245           if (in[0] == '\\' && in[1] == '\n')
2246             in += 2;
2247           else if (in[0] == '#')
2248             while (*in && *in != '\n')
2249               in++;
2250
2251           else
2252             *out++ = *in++;
2253         }
2254       *out = 0;
2255
2256       if (suffix[0] == '*')
2257         {
2258           if (! strcmp (suffix, "*link_command"))
2259             link_command_spec = spec;
2260           else
2261             set_spec (suffix + 1, spec);
2262         }
2263       else
2264         {
2265           /* Add this pair to the vector.  */
2266           compilers
2267             = xrealloc (compilers,
2268                         (n_compilers + 2) * sizeof (struct compiler));
2269
2270           compilers[n_compilers].suffix = suffix;
2271           compilers[n_compilers].spec = spec;
2272           n_compilers++;
2273           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2274         }
2275
2276       if (*suffix == 0)
2277         link_command_spec = spec;
2278     }
2279
2280   if (link_command_spec == 0)
2281     fatal ("spec file has no spec for linking");
2282 }
2283 \f
2284 /* Record the names of temporary files we tell compilers to write,
2285    and delete them at the end of the run.  */
2286
2287 /* This is the common prefix we use to make temp file names.
2288    It is chosen once for each run of this program.
2289    It is substituted into a spec by %g or %j.
2290    Thus, all temp file names contain this prefix.
2291    In practice, all temp file names start with this prefix.
2292
2293    This prefix comes from the envvar TMPDIR if it is defined;
2294    otherwise, from the P_tmpdir macro if that is defined;
2295    otherwise, in /usr/tmp or /tmp;
2296    or finally the current directory if all else fails.  */
2297
2298 static const char *temp_filename;
2299
2300 /* Length of the prefix.  */
2301
2302 static int temp_filename_length;
2303
2304 /* Define the list of temporary files to delete.  */
2305
2306 struct temp_file
2307 {
2308   const char *name;
2309   struct temp_file *next;
2310 };
2311
2312 /* Queue of files to delete on success or failure of compilation.  */
2313 static struct temp_file *always_delete_queue;
2314 /* Queue of files to delete on failure of compilation.  */
2315 static struct temp_file *failure_delete_queue;
2316
2317 /* Record FILENAME as a file to be deleted automatically.
2318    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2319    otherwise delete it in any case.
2320    FAIL_DELETE nonzero means delete it if a compilation step fails;
2321    otherwise delete it in any case.  */
2322
2323 void
2324 record_temp_file (const char *filename, int always_delete, int fail_delete)
2325 {
2326   char *const name = xstrdup (filename);
2327
2328   if (always_delete)
2329     {
2330       struct temp_file *temp;
2331       for (temp = always_delete_queue; temp; temp = temp->next)
2332         if (! strcmp (name, temp->name))
2333           goto already1;
2334
2335       temp = XNEW (struct temp_file);
2336       temp->next = always_delete_queue;
2337       temp->name = name;
2338       always_delete_queue = temp;
2339
2340     already1:;
2341     }
2342
2343   if (fail_delete)
2344     {
2345       struct temp_file *temp;
2346       for (temp = failure_delete_queue; temp; temp = temp->next)
2347         if (! strcmp (name, temp->name))
2348           goto already2;
2349
2350       temp = XNEW (struct temp_file);
2351       temp->next = failure_delete_queue;
2352       temp->name = name;
2353       failure_delete_queue = temp;
2354
2355     already2:;
2356     }
2357 }
2358
2359 /* Delete all the temporary files whose names we previously recorded.  */
2360
2361 #ifndef DELETE_IF_ORDINARY
2362 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2363 do                                                      \
2364   {                                                     \
2365     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2366       if (unlink (NAME) < 0)                            \
2367         if (VERBOSE_FLAG)                               \
2368           perror_with_name (NAME);                      \
2369   } while (0)
2370 #endif
2371
2372 static void
2373 delete_if_ordinary (const char *name)
2374 {
2375   struct stat st;
2376 #ifdef DEBUG
2377   int i, c;
2378
2379   printf ("Delete %s? (y or n) ", name);
2380   fflush (stdout);
2381   i = getchar ();
2382   if (i != '\n')
2383     while ((c = getchar ()) != '\n' && c != EOF)
2384       ;
2385
2386   if (i == 'y' || i == 'Y')
2387 #endif /* DEBUG */
2388   DELETE_IF_ORDINARY (name, st, verbose_flag);
2389 }
2390
2391 static void
2392 delete_temp_files (void)
2393 {
2394   struct temp_file *temp;
2395
2396   for (temp = always_delete_queue; temp; temp = temp->next)
2397     delete_if_ordinary (temp->name);
2398   always_delete_queue = 0;
2399 }
2400
2401 /* Delete all the files to be deleted on error.  */
2402
2403 static void
2404 delete_failure_queue (void)
2405 {
2406   struct temp_file *temp;
2407
2408   for (temp = failure_delete_queue; temp; temp = temp->next)
2409     delete_if_ordinary (temp->name);
2410 }
2411
2412 static void
2413 clear_failure_queue (void)
2414 {
2415   failure_delete_queue = 0;
2416 }
2417 \f
2418 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2419    returns non-NULL.
2420    If DO_MULTI is true iterate over the paths twice, first with multilib
2421    suffix then without, otherwise iterate over the paths once without
2422    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2423    to avoid visiting the same path twice, but we could do better.  For
2424    instance, /usr/lib/../lib is considered different from /usr/lib.
2425    At least EXTRA_SPACE chars past the end of the path passed to
2426    CALLBACK are available for use by the callback.
2427    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2428
2429    Returns the value returned by CALLBACK.  */
2430
2431 static void *
2432 for_each_path (const struct path_prefix *paths,
2433                bool do_multi,
2434                size_t extra_space,
2435                void *(*callback) (char *, void *),
2436                void *callback_info)
2437 {
2438   struct prefix_list *pl;
2439   const char *multi_dir = NULL;
2440   const char *multi_os_dir = NULL;
2441   const char *multi_suffix;
2442   const char *just_multi_suffix;
2443   char *path = NULL;
2444   void *ret = NULL;
2445   bool skip_multi_dir = false;
2446   bool skip_multi_os_dir = false;
2447
2448   multi_suffix = machine_suffix;
2449   just_multi_suffix = just_machine_suffix;
2450   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2451     {
2452       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2453       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2454       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2455     }
2456   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2457     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2458
2459   while (1)
2460     {
2461       size_t multi_dir_len = 0;
2462       size_t multi_os_dir_len = 0;
2463       size_t suffix_len;
2464       size_t just_suffix_len;
2465       size_t len;
2466
2467       if (multi_dir)
2468         multi_dir_len = strlen (multi_dir);
2469       if (multi_os_dir)
2470         multi_os_dir_len = strlen (multi_os_dir);
2471       suffix_len = strlen (multi_suffix);
2472       just_suffix_len = strlen (just_multi_suffix);
2473
2474       if (path == NULL)
2475         {
2476           len = paths->max_len + extra_space + 1;
2477           if (suffix_len > multi_os_dir_len)
2478             len += suffix_len;
2479           else
2480             len += multi_os_dir_len;
2481           path = XNEWVEC (char, len);
2482         }
2483
2484       for (pl = paths->plist; pl != 0; pl = pl->next)
2485         {
2486           len = strlen (pl->prefix);
2487           memcpy (path, pl->prefix, len);
2488
2489           /* Look first in MACHINE/VERSION subdirectory.  */
2490           if (!skip_multi_dir)
2491             {
2492               memcpy (path + len, multi_suffix, suffix_len + 1);
2493               ret = callback (path, callback_info);
2494               if (ret)
2495                 break;
2496             }
2497
2498           /* Some paths are tried with just the machine (ie. target)
2499              subdir.  This is used for finding as, ld, etc.  */
2500           if (!skip_multi_dir
2501               && pl->require_machine_suffix == 2)
2502             {
2503               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2504               ret = callback (path, callback_info);
2505               if (ret)
2506                 break;
2507             }
2508
2509           /* Now try the base path.  */
2510           if (!pl->require_machine_suffix
2511               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2512             {
2513               const char *this_multi;
2514               size_t this_multi_len;
2515
2516               if (pl->os_multilib)
2517                 {
2518                   this_multi = multi_os_dir;
2519                   this_multi_len = multi_os_dir_len;
2520                 }
2521               else
2522                 {
2523                   this_multi = multi_dir;
2524                   this_multi_len = multi_dir_len;
2525                 }
2526
2527               if (this_multi_len)
2528                 memcpy (path + len, this_multi, this_multi_len + 1);
2529               else
2530                 path[len] = '\0';
2531
2532               ret = callback (path, callback_info);
2533               if (ret)
2534                 break;
2535             }
2536         }
2537       if (pl)
2538         break;
2539
2540       if (multi_dir == NULL && multi_os_dir == NULL)
2541         break;
2542
2543       /* Run through the paths again, this time without multilibs.
2544          Don't repeat any we have already seen.  */
2545       if (multi_dir)
2546         {
2547           free (CONST_CAST (char *, multi_dir));
2548           multi_dir = NULL;
2549           free (CONST_CAST (char *, multi_suffix));
2550           multi_suffix = machine_suffix;
2551           free (CONST_CAST (char *, just_multi_suffix));
2552           just_multi_suffix = just_machine_suffix;
2553         }
2554       else
2555         skip_multi_dir = true;
2556       if (multi_os_dir)
2557         {
2558           free (CONST_CAST (char *, multi_os_dir));
2559           multi_os_dir = NULL;
2560         }
2561       else
2562         skip_multi_os_dir = true;
2563     }
2564
2565   if (multi_dir)
2566     {
2567       free (CONST_CAST (char *, multi_dir));
2568       free (CONST_CAST (char *, multi_suffix));
2569       free (CONST_CAST (char *, just_multi_suffix));
2570     }
2571   if (multi_os_dir)
2572     free (CONST_CAST (char *, multi_os_dir));
2573   if (ret != path)
2574     free (path);
2575   return ret;
2576 }
2577
2578 /* Callback for build_search_list.  Adds path to obstack being built.  */
2579
2580 struct add_to_obstack_info {
2581   struct obstack *ob;
2582   bool check_dir;
2583   bool first_time;
2584 };
2585
2586 static void *
2587 add_to_obstack (char *path, void *data)
2588 {
2589   struct add_to_obstack_info *info = data;
2590
2591   if (info->check_dir && !is_directory (path, false))
2592     return NULL;
2593
2594   if (!info->first_time)
2595     obstack_1grow (info->ob, PATH_SEPARATOR);
2596
2597   obstack_grow (info->ob, path, strlen (path));
2598
2599   info->first_time = false;
2600   return NULL;
2601 }
2602
2603 /* Add or change the value of an environment variable, outputting the
2604    change to standard error if in verbose mode.  */
2605 static void
2606 xputenv (char *string)
2607 {
2608   if (verbose_flag)
2609     notice ("%s\n", string);
2610   putenv (string);
2611 }
2612
2613 /* Build a list of search directories from PATHS.
2614    PREFIX is a string to prepend to the list.
2615    If CHECK_DIR_P is true we ensure the directory exists.
2616    If DO_MULTI is true, multilib paths are output first, then
2617    non-multilib paths.
2618    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2619    It is also used by the --print-search-dirs flag.  */
2620
2621 static char *
2622 build_search_list (const struct path_prefix *paths, const char *prefix,
2623                    bool check_dir, bool do_multi)
2624 {
2625   struct add_to_obstack_info info;
2626
2627   info.ob = &collect_obstack;
2628   info.check_dir = check_dir;
2629   info.first_time = true;
2630
2631   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2632   obstack_1grow (&collect_obstack, '=');
2633
2634   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2635
2636   obstack_1grow (&collect_obstack, '\0');
2637   return XOBFINISH (&collect_obstack, char *);
2638 }
2639
2640 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2641    for collect.  */
2642
2643 static void
2644 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2645                       bool do_multi)
2646 {
2647   xputenv (build_search_list (paths, env_var, true, do_multi));
2648 }
2649 \f
2650 /* Check whether NAME can be accessed in MODE.  This is like access,
2651    except that it never considers directories to be executable.  */
2652
2653 static int
2654 access_check (const char *name, int mode)
2655 {
2656   if (mode == X_OK)
2657     {
2658       struct stat st;
2659
2660       if (stat (name, &st) < 0
2661           || S_ISDIR (st.st_mode))
2662         return -1;
2663     }
2664
2665   return access (name, mode);
2666 }
2667
2668 /* Callback for find_a_file.  Appends the file name to the directory
2669    path.  If the resulting file exists in the right mode, return the
2670    full pathname to the file.  */
2671
2672 struct file_at_path_info {
2673   const char *name;
2674   const char *suffix;
2675   int name_len;
2676   int suffix_len;
2677   int mode;
2678 };
2679
2680 static void *
2681 file_at_path (char *path, void *data)
2682 {
2683   struct file_at_path_info *info = data;
2684   size_t len = strlen (path);
2685
2686   memcpy (path + len, info->name, info->name_len);
2687   len += info->name_len;
2688
2689   /* Some systems have a suffix for executable files.
2690      So try appending that first.  */
2691   if (info->suffix_len)
2692     {
2693       memcpy (path + len, info->suffix, info->suffix_len + 1);
2694       if (access_check (path, info->mode) == 0)
2695         return path;
2696     }
2697
2698   path[len] = '\0';
2699   if (access_check (path, info->mode) == 0)
2700     return path;
2701
2702   return NULL;
2703 }
2704
2705 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2706    access to check permissions.  If DO_MULTI is true, search multilib
2707    paths then non-multilib paths, otherwise do not search multilib paths.
2708    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2709
2710 static char *
2711 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2712              bool do_multi)
2713 {
2714   struct file_at_path_info info;
2715
2716 #ifdef DEFAULT_ASSEMBLER
2717   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2718     return xstrdup (DEFAULT_ASSEMBLER);
2719 #endif
2720
2721 #ifdef DEFAULT_LINKER
2722   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2723     return xstrdup (DEFAULT_LINKER);
2724 #endif
2725
2726   /* Determine the filename to execute (special case for absolute paths).  */
2727
2728   if (IS_ABSOLUTE_PATH (name))
2729     {
2730       if (access (name, mode) == 0)
2731         return xstrdup (name);
2732
2733       return NULL;
2734     }
2735
2736   info.name = name;
2737   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2738   info.name_len = strlen (info.name);
2739   info.suffix_len = strlen (info.suffix);
2740   info.mode = mode;
2741
2742   return for_each_path (pprefix, do_multi, info.name_len + info.suffix_len,
2743                         file_at_path, &info);
2744 }
2745
2746 /* Ranking of prefixes in the sort list. -B prefixes are put before
2747    all others.  */
2748
2749 enum path_prefix_priority
2750 {
2751   PREFIX_PRIORITY_B_OPT,
2752   PREFIX_PRIORITY_LAST
2753 };
2754
2755 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2756    order according to PRIORITY.  Within each PRIORITY, new entries are
2757    appended.
2758
2759    If WARN is nonzero, we will warn if no file is found
2760    through this prefix.  WARN should point to an int
2761    which will be set to 1 if this entry is used.
2762
2763    COMPONENT is the value to be passed to update_path.
2764
2765    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2766    the complete value of machine_suffix.
2767    2 means try both machine_suffix and just_machine_suffix.  */
2768
2769 static void
2770 add_prefix (struct path_prefix *pprefix, const char *prefix,
2771             const char *component, /* enum prefix_priority */ int priority,
2772             int require_machine_suffix, int os_multilib)
2773 {
2774   struct prefix_list *pl, **prev;
2775   int len;
2776
2777   for (prev = &pprefix->plist;
2778        (*prev) != NULL && (*prev)->priority <= priority;
2779        prev = &(*prev)->next)
2780     ;
2781
2782   /* Keep track of the longest prefix.  */
2783
2784   prefix = update_path (prefix, component);
2785   len = strlen (prefix);
2786   if (len > pprefix->max_len)
2787     pprefix->max_len = len;
2788
2789   pl = XNEW (struct prefix_list);
2790   pl->prefix = prefix;
2791   pl->require_machine_suffix = require_machine_suffix;
2792   pl->priority = priority;
2793   pl->os_multilib = os_multilib;
2794
2795   /* Insert after PREV.  */
2796   pl->next = (*prev);
2797   (*prev) = pl;
2798 }
2799
2800 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2801 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2802 static void
2803 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2804                       const char *component,
2805                       /* enum prefix_priority */ int priority,
2806                       int require_machine_suffix, int os_multilib)
2807 {
2808   if (!IS_ABSOLUTE_PATH (prefix))
2809     fatal ("system path '%s' is not absolute", prefix);
2810
2811   if (target_system_root)
2812     {
2813       if (target_sysroot_suffix)
2814           prefix = concat (target_sysroot_suffix, prefix, NULL);
2815       prefix = concat (target_system_root, prefix, NULL);
2816
2817       /* We have to override this because GCC's notion of sysroot
2818          moves along with GCC.  */
2819       component = "GCC";
2820     }
2821
2822   add_prefix (pprefix, prefix, component, priority,
2823               require_machine_suffix, os_multilib);
2824 }
2825 \f
2826 /* Execute the command specified by the arguments on the current line of spec.
2827    When using pipes, this includes several piped-together commands
2828    with `|' between them.
2829
2830    Return 0 if successful, -1 if failed.  */
2831
2832 static int
2833 execute (void)
2834 {
2835   int i;
2836   int n_commands;               /* # of command.  */
2837   char *string;
2838   struct pex_obj *pex;
2839   struct command
2840   {
2841     const char *prog;           /* program name.  */
2842     const char **argv;          /* vector of args.  */
2843   };
2844
2845   struct command *commands;     /* each command buffer with above info.  */
2846
2847   gcc_assert (!processing_spec_function);
2848
2849   /* Count # of piped commands.  */
2850   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2851     if (strcmp (argbuf[i], "|") == 0)
2852       n_commands++;
2853
2854   /* Get storage for each command.  */
2855   commands = alloca (n_commands * sizeof (struct command));
2856
2857   /* Split argbuf into its separate piped processes,
2858      and record info about each one.
2859      Also search for the programs that are to be run.  */
2860
2861   commands[0].prog = argbuf[0]; /* first command.  */
2862   commands[0].argv = &argbuf[0];
2863   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2864
2865   if (string)
2866     commands[0].argv[0] = string;
2867
2868   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2869     if (strcmp (argbuf[i], "|") == 0)
2870       {                         /* each command.  */
2871 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2872         fatal ("-pipe not supported");
2873 #endif
2874         argbuf[i] = 0;  /* termination of command args.  */
2875         commands[n_commands].prog = argbuf[i + 1];
2876         commands[n_commands].argv = &argbuf[i + 1];
2877         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2878                               X_OK, false);
2879         if (string)
2880           commands[n_commands].argv[0] = string;
2881         n_commands++;
2882       }
2883
2884   argbuf[argbuf_index] = 0;
2885
2886   /* If -v, print what we are about to do, and maybe query.  */
2887
2888   if (verbose_flag)
2889     {
2890       /* For help listings, put a blank line between sub-processes.  */
2891       if (print_help_list)
2892         fputc ('\n', stderr);
2893
2894       /* Print each piped command as a separate line.  */
2895       for (i = 0; i < n_commands; i++)
2896         {
2897           const char *const *j;
2898
2899           if (verbose_only_flag)
2900             {
2901               for (j = commands[i].argv; *j; j++)
2902                 {
2903                   const char *p;
2904                   fprintf (stderr, " \"");
2905                   for (p = *j; *p; ++p)
2906                     {
2907                       if (*p == '"' || *p == '\\' || *p == '$')
2908                         fputc ('\\', stderr);
2909                       fputc (*p, stderr);
2910                     }
2911                   fputc ('"', stderr);
2912                 }
2913             }
2914           else
2915             for (j = commands[i].argv; *j; j++)
2916               fprintf (stderr, " %s", *j);
2917
2918           /* Print a pipe symbol after all but the last command.  */
2919           if (i + 1 != n_commands)
2920             fprintf (stderr, " |");
2921           fprintf (stderr, "\n");
2922         }
2923       fflush (stderr);
2924       if (verbose_only_flag != 0)
2925         {
2926           /* verbose_only_flag should act as if the spec was
2927              executed, so increment execution_count before
2928              returning.  This prevents spurious warnings about
2929              unused linker input files, etc.  */
2930           execution_count++;
2931           return 0;
2932         }
2933 #ifdef DEBUG
2934       notice ("\nGo ahead? (y or n) ");
2935       fflush (stderr);
2936       i = getchar ();
2937       if (i != '\n')
2938         while (getchar () != '\n')
2939           ;
2940
2941       if (i != 'y' && i != 'Y')
2942         return 0;
2943 #endif /* DEBUG */
2944     }
2945
2946 #ifdef ENABLE_VALGRIND_CHECKING
2947   /* Run the each command through valgrind.  To simplify prepending the
2948      path to valgrind and the option "-q" (for quiet operation unless
2949      something triggers), we allocate a separate argv array.  */
2950
2951   for (i = 0; i < n_commands; i++)
2952     {
2953       const char **argv;
2954       int argc;
2955       int j;
2956
2957       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2958         ;
2959
2960       argv = alloca ((argc + 3) * sizeof (char *));
2961
2962       argv[0] = VALGRIND_PATH;
2963       argv[1] = "-q";
2964       for (j = 2; j < argc + 2; j++)
2965         argv[j] = commands[i].argv[j - 2];
2966       argv[j] = NULL;
2967
2968       commands[i].argv = argv;
2969       commands[i].prog = argv[0];
2970     }
2971 #endif
2972
2973   /* Run each piped subprocess.  */
2974
2975   pex = pex_init (PEX_USE_PIPES | (report_times ? PEX_RECORD_TIMES : 0),
2976                   programname, temp_filename);
2977   if (pex == NULL)
2978     pfatal_with_name (_("pex_init failed"));
2979
2980   for (i = 0; i < n_commands; i++)
2981     {
2982       const char *errmsg;
2983       int err;
2984       const char *string = commands[i].argv[0];
2985
2986       errmsg = pex_run (pex,
2987                         ((i + 1 == n_commands ? PEX_LAST : 0)
2988                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2989                         string, CONST_CAST (char **, commands[i].argv),
2990                         NULL, NULL, &err);
2991       if (errmsg != NULL)
2992         {
2993           if (err == 0)
2994             fatal (errmsg);
2995           else
2996             {
2997               errno = err;
2998               pfatal_with_name (errmsg);
2999             }
3000         }
3001
3002       if (string != commands[i].prog)
3003         free (CONST_CAST (char *, string));
3004     }
3005
3006   execution_count++;
3007
3008   /* Wait for all the subprocesses to finish.  */
3009
3010   {
3011     int *statuses;
3012     struct pex_time *times = NULL;
3013     int ret_code = 0;
3014
3015     statuses = alloca (n_commands * sizeof (int));
3016     if (!pex_get_status (pex, n_commands, statuses))
3017       pfatal_with_name (_("failed to get exit status"));
3018
3019     if (report_times)
3020       {
3021         times = alloca (n_commands * sizeof (struct pex_time));
3022         if (!pex_get_times (pex, n_commands, times))
3023           pfatal_with_name (_("failed to get process times"));
3024       }
3025
3026     pex_free (pex);
3027
3028     for (i = 0; i < n_commands; ++i)
3029       {
3030         int status = statuses[i];
3031
3032         if (WIFSIGNALED (status))
3033           {
3034 #ifdef SIGPIPE
3035             /* SIGPIPE is a special case.  It happens in -pipe mode
3036                when the compiler dies before the preprocessor is done,
3037                or the assembler dies before the compiler is done.
3038                There's generally been an error already, and this is
3039                just fallout.  So don't generate another error unless
3040                we would otherwise have succeeded.  */
3041             if (WTERMSIG (status) == SIGPIPE
3042                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3043               {
3044                 signal_count++;
3045                 ret_code = -1;
3046               }
3047             else
3048 #endif
3049               fatal_ice ("\
3050 Internal error: %s (program %s)\n\
3051 Please submit a full bug report.\n\
3052 See %s for instructions.",
3053                         strsignal (WTERMSIG (status)), commands[i].prog,
3054                         bug_report_url);
3055           }
3056         else if (WIFEXITED (status)
3057                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3058           {
3059             if (WEXITSTATUS (status) > greatest_status)
3060               greatest_status = WEXITSTATUS (status);
3061             ret_code = -1;
3062           }
3063
3064         if (report_times)
3065           {
3066             struct pex_time *pt = &times[i];
3067             double ut, st;
3068
3069             ut = ((double) pt->user_seconds
3070                   + (double) pt->user_microseconds / 1.0e6);
3071             st = ((double) pt->system_seconds
3072                   + (double) pt->system_microseconds / 1.0e6);
3073
3074             if (ut + st != 0)
3075               notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3076           }
3077       }
3078
3079     return ret_code;
3080   }
3081 }
3082 \f
3083 /* Find all the switches given to us
3084    and make a vector describing them.
3085    The elements of the vector are strings, one per switch given.
3086    If a switch uses following arguments, then the `part1' field
3087    is the switch itself and the `args' field
3088    is a null-terminated vector containing the following arguments.
3089    The `live_cond' field is:
3090    0 when initialized
3091    1 if the switch is true in a conditional spec,
3092    -1 if false (overridden by a later switch)
3093    -2 if this switch should be ignored (used in %<S)
3094    The `validated' field is nonzero if any spec has looked at this switch;
3095    if it remains zero at the end of the run, it must be meaningless.  */
3096
3097 #define SWITCH_OK       0
3098 #define SWITCH_FALSE   -1
3099 #define SWITCH_IGNORE  -2
3100 #define SWITCH_LIVE     1
3101
3102 struct switchstr
3103 {
3104   const char *part1;
3105   const char **args;
3106   int live_cond;
3107   unsigned char validated;
3108   unsigned char ordering;
3109 };
3110
3111 static struct switchstr *switches;
3112
3113 static int n_switches;
3114
3115 /* Language is one of three things:
3116
3117    1) The name of a real programming language.
3118    2) NULL, indicating that no one has figured out
3119    what it is yet.
3120    3) '*', indicating that the file should be passed
3121    to the linker.  */
3122 struct infile
3123 {
3124   const char *name;
3125   const char *language;
3126   struct compiler *incompiler;
3127   bool compiled;
3128   bool preprocessed;
3129 };
3130
3131 /* Also a vector of input files specified.  */
3132
3133 static struct infile *infiles;
3134
3135 int n_infiles;
3136
3137 /* True if multiple input files are being compiled to a single
3138    assembly file.  */
3139
3140 static bool combine_inputs;
3141
3142 /* This counts the number of libraries added by lang_specific_driver, so that
3143    we can tell if there were any user supplied any files or libraries.  */
3144
3145 static int added_libraries;
3146
3147 /* And a vector of corresponding output files is made up later.  */
3148
3149 const char **outfiles;
3150 \f
3151 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3152
3153 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
3154    is true if we should look for an executable suffix.  DO_OBJ
3155    is true if we should look for an object suffix.  */
3156
3157 static const char *
3158 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3159                   int do_obj ATTRIBUTE_UNUSED)
3160 {
3161 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3162   int i;
3163 #endif
3164   int len;
3165
3166   if (name == NULL)
3167     return NULL;
3168
3169   len = strlen (name);
3170
3171 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3172   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
3173   if (do_obj && len > 2
3174       && name[len - 2] == '.'
3175       && name[len - 1] == 'o')
3176     {
3177       obstack_grow (&obstack, name, len - 2);
3178       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3179       name = XOBFINISH (&obstack, const char *);
3180     }
3181 #endif
3182
3183 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3184   /* If there is no filetype, make it the executable suffix (which includes
3185      the ".").  But don't get confused if we have just "-o".  */
3186   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3187     return name;
3188
3189   for (i = len - 1; i >= 0; i--)
3190     if (IS_DIR_SEPARATOR (name[i]))
3191       break;
3192
3193   for (i++; i < len; i++)
3194     if (name[i] == '.')
3195       return name;
3196
3197   obstack_grow (&obstack, name, len);
3198   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3199                  strlen (TARGET_EXECUTABLE_SUFFIX));
3200   name = XOBFINISH (&obstack, const char *);
3201 #endif
3202
3203   return name;
3204 }
3205 #endif
3206 \f
3207 /* Display the command line switches accepted by gcc.  */
3208 static void
3209 display_help (void)
3210 {
3211   printf (_("Usage: %s [options] file...\n"), programname);
3212   fputs (_("Options:\n"), stdout);
3213
3214   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3215   fputs (_("  --help                   Display this information\n"), stdout);
3216   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3217   fputs (_("  --help={target|optimizers|warnings|undocumented|params}[,{[^]joined|[^]separate}]\n"), stdout);
3218   fputs (_("                           Display specific types of command line options\n"), stdout);
3219   if (! verbose_flag)
3220     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3221   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3222   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3223   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3224   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3225   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3226   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3227   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3228   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3229   fputs (_("\
3230   -print-multi-lib         Display the mapping between command line options and\n\
3231                            multiple library search directories\n"), stdout);
3232   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3233   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3234   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3235   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3236   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3237   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3238   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3239   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3240   fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3241   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3242   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3243   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3244   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3245   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3246   fputs (_("\
3247   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3248                            and libraries\n"), stdout);
3249   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3250   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3251   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3252   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3253   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3254   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3255   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3256   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3257   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3258   fputs (_("\
3259   -x <language>            Specify the language of the following input files\n\
3260                            Permissible languages include: c c++ assembler none\n\
3261                            'none' means revert to the default behavior of\n\
3262                            guessing the language based on the file's extension\n\
3263 "), stdout);
3264
3265   printf (_("\
3266 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3267  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3268  other options on to these processes the -W<letter> options must be used.\n\
3269 "), programname);
3270
3271   /* The rest of the options are displayed by invocations of the various
3272      sub-processes.  */
3273 }
3274
3275 static void
3276 add_preprocessor_option (const char *option, int len)
3277 {
3278   n_preprocessor_options++;
3279
3280   if (! preprocessor_options)
3281     preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3282   else
3283     preprocessor_options = xrealloc (preprocessor_options,
3284                                      n_preprocessor_options * sizeof (char *));
3285
3286   preprocessor_options [n_preprocessor_options - 1] =
3287     save_string (option, len);
3288 }
3289
3290 static void
3291 add_assembler_option (const char *option, int len)
3292 {
3293   n_assembler_options++;
3294
3295   if (! assembler_options)
3296     assembler_options = XNEWVEC (char *, n_assembler_options);
3297   else
3298     assembler_options = xrealloc (assembler_options,
3299                                   n_assembler_options * sizeof (char *));
3300
3301   assembler_options [n_assembler_options - 1] = save_string (option, len);
3302 }
3303
3304 static void
3305 add_linker_option (const char *option, int len)
3306 {
3307   n_linker_options++;
3308
3309   if (! linker_options)
3310     linker_options = XNEWVEC (char *, n_linker_options);
3311   else
3312     linker_options = xrealloc (linker_options,
3313                                n_linker_options * sizeof (char *));
3314
3315   linker_options [n_linker_options - 1] = save_string (option, len);
3316 }
3317 \f
3318 /* Create the vector `switches' and its contents.
3319    Store its length in `n_switches'.  */
3320
3321 static void
3322 process_command (int argc, const char **argv)
3323 {
3324   int i;
3325   const char *temp;
3326   char *temp1;
3327   const char *spec_lang = 0;
3328   int last_language_n_infiles;
3329   int lang_n_infiles = 0;
3330 #ifdef MODIFY_TARGET_NAME
3331   int is_modify_target_name;
3332   unsigned int j;
3333 #endif
3334   const char *tooldir_prefix;
3335
3336   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3337
3338   n_switches = 0;
3339   n_infiles = 0;
3340   added_libraries = 0;
3341
3342   /* Figure compiler version from version string.  */
3343
3344   compiler_version = temp1 = xstrdup (version_string);
3345
3346   for (; *temp1; ++temp1)
3347     {
3348       if (*temp1 == ' ')
3349         {
3350           *temp1 = '\0';
3351           break;
3352         }
3353     }
3354
3355   /* If there is a -V or -b option (or both), process it now, before
3356      trying to interpret the rest of the command line.
3357      Use heuristic that all configuration names must have at least
3358      one dash '-'. This allows us to pass options starting with -b.  */
3359   if (argc > 1 && argv[1][0] == '-'
3360       && (argv[1][1] == 'V' ||
3361          ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
3362     {
3363       const char *new_version = DEFAULT_TARGET_VERSION;
3364       const char *new_machine = DEFAULT_TARGET_MACHINE;
3365       const char *progname = argv[0];
3366       char **new_argv;
3367       char *new_argv0;
3368       int baselen;
3369
3370       while (argc > 1 && argv[1][0] == '-'
3371              && (argv[1][1] == 'V' ||
3372                 ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
3373         {
3374           char opt = argv[1][1];
3375           const char *arg;
3376           if (argv[1][2] != '\0')
3377             {
3378               arg = argv[1] + 2;
3379               argc -= 1;
3380               argv += 1;
3381             }
3382           else if (argc > 2)
3383             {
3384               arg = argv[2];
3385               argc -= 2;
3386               argv += 2;
3387             }
3388           else
3389             fatal ("'-%c' option must have argument", opt);
3390           if (opt == 'V')
3391             new_version = arg;
3392           else
3393             new_machine = arg;
3394         }
3395
3396       for (baselen = strlen (progname); baselen > 0; baselen--)
3397         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3398           break;
3399       new_argv0 = xmemdup (progname, baselen,
3400                            baselen + concat_length (new_version, new_machine,
3401                                                     "-gcc-", NULL) + 1);
3402       strcpy (new_argv0 + baselen, new_machine);
3403       strcat (new_argv0, "-gcc-");
3404       strcat (new_argv0, new_version);
3405
3406       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3407                           (argc + 1) * sizeof (argv[0]));
3408       new_argv[0] = new_argv0;
3409
3410       execvp (new_argv0, new_argv);
3411       fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3412     }
3413
3414   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3415      see if we can create it from the pathname specified in argv[0].  */
3416
3417   gcc_libexec_prefix = standard_libexec_prefix;
3418 #ifndef VMS
3419   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3420   if (!gcc_exec_prefix)
3421     {
3422       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3423                                               standard_exec_prefix);
3424       gcc_libexec_prefix = make_relative_prefix (argv[0],
3425                                                  standard_bindir_prefix,
3426                                                  standard_libexec_prefix);
3427       if (gcc_exec_prefix)
3428         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3429     }
3430   else
3431     {
3432       /* make_relative_prefix requires a program name, but
3433          GCC_EXEC_PREFIX is typically a directory name with a trailing
3434          / (which is ignored by make_relative_prefix), so append a
3435          program name.  */
3436       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3437       gcc_libexec_prefix = make_relative_prefix (tmp_prefix,
3438                                                  standard_exec_prefix,
3439                                                  standard_libexec_prefix);
3440
3441       /* The path is unrelocated, so fallback to the original setting.  */
3442       if (!gcc_libexec_prefix)
3443         gcc_libexec_prefix = standard_libexec_prefix;
3444
3445       free (tmp_prefix);
3446     }
3447 #else
3448 #endif
3449   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3450      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3451      or an automatically created GCC_EXEC_PREFIX from argv[0].  */
3452
3453   if (gcc_exec_prefix)
3454     {
3455       int len = strlen (gcc_exec_prefix);
3456
3457       if (len > (int) sizeof ("/lib/gcc/") - 1
3458           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3459         {
3460           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3461           if (IS_DIR_SEPARATOR (*temp)
3462               && strncmp (temp + 1, "lib", 3) == 0
3463               && IS_DIR_SEPARATOR (temp[4])
3464               && strncmp (temp + 5, "gcc", 3) == 0)
3465             len -= sizeof ("/lib/gcc/") - 1;
3466         }
3467
3468       set_std_prefix (gcc_exec_prefix, len);
3469       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3470                   PREFIX_PRIORITY_LAST, 0, 0);
3471       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3472                   PREFIX_PRIORITY_LAST, 0, 0);
3473     }
3474
3475   /* COMPILER_PATH and LIBRARY_PATH have values
3476      that are lists of directory names with colons.  */
3477
3478   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3479   if (temp)
3480     {
3481       const char *startp, *endp;
3482       char *nstore = alloca (strlen (temp) + 3);
3483
3484       startp = endp = temp;
3485       while (1)
3486         {
3487           if (*endp == PATH_SEPARATOR || *endp == 0)
3488             {
3489               strncpy (nstore, startp, endp - startp);
3490               if (endp == startp)
3491                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3492               else if (!IS_DIR_SEPARATOR (endp[-1]))
3493                 {
3494                   nstore[endp - startp] = DIR_SEPARATOR;
3495                   nstore[endp - startp + 1] = 0;
3496                 }
3497               else
3498                 nstore[endp - startp] = 0;
3499               add_prefix (&exec_prefixes, nstore, 0,
3500                           PREFIX_PRIORITY_LAST, 0, 0);
3501               add_prefix (&include_prefixes, nstore, 0,
3502                           PREFIX_PRIORITY_LAST, 0, 0);
3503               if (*endp == 0)
3504                 break;
3505               endp = startp = endp + 1;
3506             }
3507           else
3508             endp++;
3509         }
3510     }
3511
3512   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3513   if (temp && *cross_compile == '0')
3514     {
3515       const char *startp, *endp;
3516       char *nstore = alloca (strlen (temp) + 3);
3517
3518       startp = endp = temp;
3519       while (1)
3520         {
3521           if (*endp == PATH_SEPARATOR || *endp == 0)
3522             {
3523               strncpy (nstore, startp, endp - startp);
3524               if (endp == startp)
3525                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3526               else if (!IS_DIR_SEPARATOR (endp[-1]))
3527                 {
3528                   nstore[endp - startp] = DIR_SEPARATOR;
3529                   nstore[endp - startp + 1] = 0;
3530                 }
3531               else
3532                 nstore[endp - startp] = 0;
3533               add_prefix (&startfile_prefixes, nstore, NULL,
3534                           PREFIX_PRIORITY_LAST, 0, 1);
3535               if (*endp == 0)
3536                 break;
3537               endp = startp = endp + 1;
3538             }
3539           else
3540             endp++;
3541         }
3542     }
3543
3544   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3545   GET_ENVIRONMENT (temp, "LPATH");
3546   if (temp && *cross_compile == '0')
3547     {
3548       const char *startp, *endp;
3549       char *nstore = alloca (strlen (temp) + 3);
3550
3551       startp = endp = temp;
3552       while (1)
3553         {
3554           if (*endp == PATH_SEPARATOR || *endp == 0)
3555             {
3556               strncpy (nstore, startp, endp - startp);
3557               if (endp == startp)
3558                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3559               else if (!IS_DIR_SEPARATOR (endp[-1]))
3560                 {
3561                   nstore[endp - startp] = DIR_SEPARATOR;
3562                   nstore[endp - startp + 1] = 0;
3563                 }
3564               else
3565                 nstore[endp - startp] = 0;
3566               add_prefix (&startfile_prefixes, nstore, NULL,
3567                           PREFIX_PRIORITY_LAST, 0, 1);
3568               if (*endp == 0)
3569                 break;
3570               endp = startp = endp + 1;
3571             }
3572           else
3573             endp++;
3574         }
3575     }
3576
3577   /* Convert new-style -- options to old-style.  */
3578   translate_options (&argc, (const char *const **) &argv);
3579
3580   /* Do language-specific adjustment/addition of flags.  */
3581   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3582
3583   /* Scan argv twice.  Here, the first time, just count how many switches
3584      there will be in their vector, and how many input files in theirs.
3585      Here we also parse the switches that cc itself uses (e.g. -v).  */
3586
3587   for (i = 1; i < argc; i++)
3588     {
3589       if (! strcmp (argv[i], "-dumpspecs"))
3590         {
3591           struct spec_list *sl;
3592           init_spec ();
3593           for (sl = specs; sl; sl = sl->next)
3594             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3595           if (link_command_spec)
3596             printf ("*link_command:\n%s\n\n", link_command_spec);
3597           exit (0);
3598         }
3599       else if (! strcmp (argv[i], "-dumpversion"))
3600         {
3601           printf ("%s\n", spec_version);
3602           exit (0);
3603         }
3604       else if (! strcmp (argv[i], "-dumpmachine"))
3605         {
3606           printf ("%s\n", spec_machine);
3607           exit (0);
3608         }
3609       else if (strcmp (argv[i], "-fversion") == 0)
3610         {
3611           /* translate_options () has turned --version into -fversion.  */
3612           printf (_("%s %s%s\n"), programname, pkgversion_string,
3613                   version_string);
3614           printf ("Copyright %s 2007 Free Software Foundation, Inc.\n",
3615                   _("(C)"));
3616           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3617 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3618                  stdout);
3619           exit (0);
3620         }
3621       else if (strcmp (argv[i], "-fhelp") == 0)
3622         {
3623           /* translate_options () has turned --help into -fhelp.  */
3624           print_help_list = 1;
3625
3626           /* We will be passing a dummy file on to the sub-processes.  */
3627           n_infiles++;
3628           n_switches++;
3629
3630           /* CPP driver cannot obtain switch from cc1_options.  */
3631           if (is_cpp_driver)
3632             add_preprocessor_option ("--help", 6);
3633           add_assembler_option ("--help", 6);
3634           add_linker_option ("--help", 6);
3635         }
3636       else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3637         {
3638           /* translate_options () has turned --help into -fhelp.  */
3639           print_subprocess_help = 2;
3640
3641           /* We will be passing a dummy file on to the sub-processes.  */
3642           n_infiles++;
3643           n_switches++;
3644         }
3645       else if (strcmp (argv[i], "-ftarget-help") == 0)
3646         {
3647           /* translate_options() has turned --target-help into -ftarget-help.  */
3648           print_subprocess_help = 1;
3649
3650           /* We will be passing a dummy file on to the sub-processes.  */
3651           n_infiles++;
3652           n_switches++;
3653
3654           /* CPP driver cannot obtain switch from cc1_options.  */
3655           if (is_cpp_driver)
3656             add_preprocessor_option ("--target-help", 13);
3657           add_assembler_option ("--target-help", 13);
3658           add_linker_option ("--target-help", 13);
3659         }
3660       else if (! strcmp (argv[i], "-pass-exit-codes"))
3661         {
3662           pass_exit_codes = 1;
3663           n_switches++;
3664         }
3665       else if (! strcmp (argv[i], "-print-search-dirs"))
3666         print_search_dirs = 1;
3667       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3668         print_file_name = "libgcc.a";
3669       else if (! strncmp (argv[i], "-print-file-name=", 17))
3670         print_file_name = argv[i] + 17;
3671       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3672         print_prog_name = argv[i] + 17;
3673       else if (! strcmp (argv[i], "-print-multi-lib"))
3674         print_multi_lib = 1;
3675       else if (! strcmp (argv[i], "-print-multi-directory"))
3676         print_multi_directory = 1;
3677       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3678         print_multi_os_directory = 1;
3679       else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3680         print_sysroot_headers_suffix = 1;
3681       else if (! strncmp (argv[i], "-Wa,", 4))
3682         {
3683           int prev, j;
3684           /* Pass the rest of this option to the assembler.  */
3685
3686           /* Split the argument at commas.  */
3687           prev = 4;
3688           for (j = 4; argv[i][j]; j++)
3689             if (argv[i][j] == ',')
3690               {
3691                 add_assembler_option (argv[i] + prev, j - prev);
3692                 prev = j + 1;
3693               }
3694
3695           /* Record the part after the last comma.  */
3696           add_assembler_option (argv[i] + prev, j - prev);
3697         }
3698       else if (! strncmp (argv[i], "-Wp,", 4))
3699         {
3700           int prev, j;
3701           /* Pass the rest of this option to the preprocessor.  */
3702
3703           /* Split the argument at commas.  */
3704           prev = 4;
3705           for (j = 4; argv[i][j]; j++)
3706             if (argv[i][j] == ',')
3707               {
3708                 add_preprocessor_option (argv[i] + prev, j - prev);
3709                 prev = j + 1;
3710               }
3711
3712           /* Record the part after the last comma.  */
3713           add_preprocessor_option (argv[i] + prev, j - prev);
3714         }
3715       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3716         /* The +e options to the C++ front-end.  */
3717         n_switches++;
3718       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3719         {
3720           int j;
3721           /* Split the argument at commas.  */
3722           for (j = 3; argv[i][j]; j++)
3723             n_infiles += (argv[i][j] == ',');
3724         }
3725       else if (strcmp (argv[i], "-Xlinker") == 0)
3726         {
3727           if (i + 1 == argc)
3728             fatal ("argument to '-Xlinker' is missing");
3729
3730           n_infiles++;
3731           i++;
3732         }
3733       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3734         {
3735           if (i + 1 == argc)
3736             fatal ("argument to '-Xpreprocessor' is missing");
3737
3738           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3739         }
3740       else if (strcmp (argv[i], "-Xassembler") == 0)
3741         {
3742           if (i + 1 == argc)
3743             fatal ("argument to '-Xassembler' is missing");
3744
3745           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3746         }
3747       else if (strcmp (argv[i], "-l") == 0)
3748         {
3749           if (i + 1 == argc)
3750             fatal ("argument to '-l' is missing");
3751
3752           n_infiles++;
3753           i++;
3754         }
3755       else if (strncmp (argv[i], "-l", 2) == 0)
3756         n_infiles++;
3757       else if (strcmp (argv[i], "-save-temps") == 0)
3758         {
3759           save_temps_flag = 1;
3760           n_switches++;
3761         }
3762       else if (strcmp (argv[i], "-combine") == 0)
3763         {
3764           combine_flag = 1;
3765           n_switches++;
3766         }
3767       else if (strcmp (argv[i], "-specs") == 0)
3768         {
3769           struct user_specs *user = XNEW (struct user_specs);
3770           if (++i >= argc)
3771             fatal ("argument to '-specs' is missing");
3772
3773           user->next = (struct user_specs *) 0;
3774           user->filename = argv[i];
3775           if (user_specs_tail)
3776             user_specs_tail->next = user;
3777           else
3778             user_specs_head = user;
3779           user_specs_tail = user;
3780         }
3781       else if (strncmp (argv[i], "-specs=", 7) == 0)
3782         {
3783           struct user_specs *user = XNEW (struct user_specs);
3784           if (strlen (argv[i]) == 7)
3785             fatal ("argument to '-specs=' is missing");
3786
3787           user->next = (struct user_specs *) 0;
3788           user->filename = argv[i] + 7;
3789           if (user_specs_tail)
3790             user_specs_tail->next = user;
3791           else
3792             user_specs_head = user;
3793           user_specs_tail = user;
3794         }
3795       else if (strcmp (argv[i], "-time") == 0)
3796         report_times = 1;
3797       else if (strcmp (argv[i], "-pipe") == 0)
3798         {
3799           /* -pipe has to go into the switches array as well as
3800              setting a flag.  */
3801           use_pipes = 1;
3802           n_switches++;
3803         }
3804       else if (strcmp (argv[i], "-###") == 0)
3805         {
3806           /* This is similar to -v except that there is no execution
3807              of the commands and the echoed arguments are quoted.  It
3808              is intended for use in shell scripts to capture the
3809              driver-generated command line.  */
3810           verbose_only_flag++;
3811           verbose_flag++;
3812         }
3813       else if (argv[i][0] == '-' && argv[i][1] != 0)
3814         {
3815           const char *p = &argv[i][1];
3816           int c = *p;
3817
3818           switch (c)
3819             {
3820             case 'b':
3821               if (NULL == strchr(argv[i] + 2, '-'))
3822                 goto normal_switch;
3823
3824               /* Fall through.  */
3825             case 'V':
3826               fatal ("'-%c' must come at the start of the command line", c);
3827               break;
3828
3829             case 'B':
3830               {
3831                 const char *value;
3832                 int len;
3833
3834                 if (p[1] == 0 && i + 1 == argc)
3835                   fatal ("argument to '-B' is missing");
3836                 if (p[1] == 0)
3837                   value = argv[++i];
3838                 else
3839                   value = p + 1;
3840
3841                 len = strlen (value);
3842
3843                 /* Catch the case where the user has forgotten to append a
3844                    directory separator to the path.  Note, they may be using
3845                    -B to add an executable name prefix, eg "i386-elf-", in
3846                    order to distinguish between multiple installations of
3847                    GCC in the same directory.  Hence we must check to see
3848                    if appending a directory separator actually makes a
3849                    valid directory name.  */
3850                 if (! IS_DIR_SEPARATOR (value [len - 1])
3851                     && is_directory (value, false))
3852                   {
3853                     char *tmp = XNEWVEC (char, len + 2);
3854                     strcpy (tmp, value);
3855                     tmp[len] = DIR_SEPARATOR;
3856                     tmp[++ len] = 0;
3857                     value = tmp;
3858                   }
3859
3860                 add_prefix (&exec_prefixes, value, NULL,
3861                             PREFIX_PRIORITY_B_OPT, 0, 0);
3862                 add_prefix (&startfile_prefixes, value, NULL,
3863                             PREFIX_PRIORITY_B_OPT, 0, 0);
3864                 add_prefix (&include_prefixes, value, NULL,
3865                             PREFIX_PRIORITY_B_OPT, 0, 0);
3866                 n_switches++;
3867               }
3868               break;
3869
3870             case 'v':   /* Print our subcommands and print versions.  */
3871               n_switches++;
3872               /* If they do anything other than exactly `-v', don't set
3873                  verbose_flag; rather, continue on to give the error.  */
3874               if (p[1] != 0)
3875                 break;
3876               verbose_flag++;
3877               break;
3878
3879             case 'S':
3880             case 'c':
3881               if (p[1] == 0)
3882                 {
3883                   have_c = 1;
3884                   n_switches++;
3885                   break;
3886                 }
3887               goto normal_switch;
3888
3889             case 'o':
3890               have_o = 1;
3891 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3892               if (! have_c)
3893                 {
3894                   int skip;
3895
3896                   /* Forward scan, just in case -S or -c is specified
3897                      after -o.  */
3898                   int j = i + 1;
3899                   if (p[1] == 0)
3900                     ++j;
3901                   while (j < argc)
3902                     {
3903                       if (argv[j][0] == '-')
3904                         {
3905                           if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3906                               && argv[j][2] == 0)
3907                             {
3908                               have_c = 1;
3909                               break;
3910                             }
3911                           else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3912                             j += skip - (argv[j][2] != 0);
3913                           else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3914                             j += skip;
3915                         }
3916                       j++;
3917                     }
3918                 }
3919 #endif
3920 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3921               if (p[1] == 0)
3922                 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3923               else
3924                 argv[i] = convert_filename (argv[i], ! have_c, 0);
3925 #endif
3926               goto normal_switch;
3927
3928             default:
3929             normal_switch:
3930
3931 #ifdef MODIFY_TARGET_NAME
3932               is_modify_target_name = 0;
3933
3934               for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3935                 if (! strcmp (argv[i], modify_target[j].sw))
3936                   {
3937                     char *new_name = xmalloc (strlen (modify_target[j].str)
3938                                               + strlen (spec_machine));
3939                     const char *p, *r;
3940                     char *q;
3941                     int made_addition = 0;
3942
3943                     is_modify_target_name = 1;
3944                     for (p = spec_machine, q = new_name; *p != 0; )
3945                       {
3946                         if (modify_target[j].add_del == DELETE
3947                             && (! strncmp (q, modify_target[j].str,
3948                                            strlen (modify_target[j].str))))
3949                           p += strlen (modify_target[j].str);
3950                         else if (modify_target[j].add_del == ADD
3951                                  && ! made_addition && *p == '-')
3952                           {
3953                             for (r = modify_target[j].str; *r != 0; )
3954                               *q++ = *r++;
3955                             made_addition = 1;
3956                           }
3957
3958                         *q++ = *p++;
3959                       }
3960
3961                     spec_machine = new_name;
3962                   }
3963
3964               if (is_modify_target_name)
3965                 break;
3966 #endif
3967
3968               n_switches++;
3969
3970               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3971                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3972               else if (WORD_SWITCH_TAKES_ARG (p))
3973                 i += WORD_SWITCH_TAKES_ARG (p);
3974             }
3975         }
3976       else
3977         {
3978           n_infiles++;
3979           lang_n_infiles++;
3980         }
3981     }
3982
3983   if (save_temps_flag && use_pipes)
3984     {
3985       /* -save-temps overrides -pipe, so that temp files are produced */
3986       if (save_temps_flag)
3987         error ("warning: -pipe ignored because -save-temps specified");
3988       use_pipes = 0;
3989     }
3990
3991   /* Set up the search paths.  We add directories that we expect to
3992      contain GNU Toolchain components before directories specified by
3993      the machine description so that we will find GNU components (like
3994      the GNU assembler) before those of the host system.  */
3995
3996   /* If we don't know where the toolchain has been installed, use the
3997      configured-in locations.  */
3998   if (!gcc_exec_prefix)
3999     {
4000 #ifndef OS2
4001       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4002                   PREFIX_PRIORITY_LAST, 1, 0);
4003       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4004                   PREFIX_PRIORITY_LAST, 2, 0);
4005       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4006                   PREFIX_PRIORITY_LAST, 2, 0);
4007 #endif
4008       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4009                   PREFIX_PRIORITY_LAST, 1, 0);
4010     }
4011
4012   /* If not cross-compiling, search well-known system locations.  */
4013   if (*cross_compile == '0')
4014     {
4015 #ifndef OS2
4016       add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
4017                   PREFIX_PRIORITY_LAST, 2, 0);
4018       add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
4019                   PREFIX_PRIORITY_LAST, 2, 0);
4020 #endif
4021       add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
4022                   PREFIX_PRIORITY_LAST, 1, 0);
4023     }
4024
4025   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4026   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4027                            dir_separator_str, NULL);
4028
4029   /* Look for tools relative to the location from which the driver is
4030      running, or, if that is not available, the configured prefix.  */
4031   tooldir_prefix
4032     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4033               spec_machine, dir_separator_str,
4034               spec_version, dir_separator_str, tooldir_prefix, NULL);
4035
4036   add_prefix (&exec_prefixes,
4037               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4038               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4039   add_prefix (&startfile_prefixes,
4040               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4041               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4042
4043 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4044   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4045      then consider it to relocate with the rest of the GCC installation
4046      if GCC_EXEC_PREFIX is set.
4047      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
4048   if (target_system_root && gcc_exec_prefix)
4049     {
4050       char *tmp_prefix = make_relative_prefix (argv[0],
4051                                                standard_bindir_prefix,
4052                                                target_system_root);
4053       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4054         {
4055           target_system_root = tmp_prefix;
4056           target_system_root_changed = 1;
4057         }
4058     }
4059 #endif
4060
4061   /* More prefixes are enabled in main, after we read the specs file
4062      and determine whether this is cross-compilation or not.  */
4063
4064   /* Then create the space for the vectors and scan again.  */
4065
4066   switches = XNEWVEC (struct switchstr, n_switches + 1);
4067   infiles = XNEWVEC (struct infile, n_infiles + 1);
4068   n_switches = 0;
4069   n_infiles = 0;
4070   last_language_n_infiles = -1;
4071
4072   /* This, time, copy the text of each switch and store a pointer
4073      to the copy in the vector of switches.
4074      Store all the infiles in their vector.  */
4075
4076   for (i = 1; i < argc; i++)
4077     {
4078       /* Just skip the switches that were handled by the preceding loop.  */
4079 #ifdef MODIFY_TARGET_NAME
4080       is_modify_target_name = 0;
4081
4082       for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4083         if (! strcmp (argv[i], modify_target[j].sw))
4084           is_modify_target_name = 1;
4085
4086       if (is_modify_target_name)
4087         ;
4088       else
4089 #endif
4090       if (! strncmp (argv[i], "-Wa,", 4))
4091         ;
4092       else if (! strncmp (argv[i], "-Wp,", 4))
4093         ;
4094       else if (! strcmp (argv[i], "-pass-exit-codes"))
4095         ;
4096       else if (! strcmp (argv[i], "-print-search-dirs"))
4097         ;
4098       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4099         ;
4100       else if (! strncmp (argv[i], "-print-file-name=", 17))
4101         ;
4102       else if (! strncmp (argv[i], "-print-prog-name=", 17))
4103         ;
4104       else if (! strcmp (argv[i], "-print-multi-lib"))
4105         ;
4106       else if (! strcmp (argv[i], "-print-multi-directory"))
4107         ;
4108       else if (! strcmp (argv[i], "-print-multi-os-directory"))
4109         ;
4110       else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4111         ;
4112       else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4113         {
4114           target_system_root = argv[i] + strlen ("--sysroot=");
4115           target_system_root_changed = 1;
4116         }
4117       else if (argv[i][0] == '+' && argv[i][1] == 'e')
4118         {
4119           /* Compensate for the +e options to the C++ front-end;
4120              they're there simply for cfront call-compatibility.  We do
4121              some magic in default_compilers to pass them down properly.
4122              Note we deliberately start at the `+' here, to avoid passing
4123              -e0 or -e1 down into the linker.  */
4124           switches[n_switches].part1 = &argv[i][0];
4125           switches[n_switches].args = 0;
4126           switches[n_switches].live_cond = SWITCH_OK;
4127           switches[n_switches].validated = 0;
4128           n_switches++;
4129         }
4130       else if (strncmp (argv[i], "-Wl,", 4) == 0)
4131         {
4132           int prev, j;
4133           /* Split the argument at commas.  */
4134           prev = 4;
4135           for (j = 4; argv[i][j]; j++)
4136             if (argv[i][j] == ',')
4137               {
4138                 infiles[n_infiles].language = "*";
4139                 infiles[n_infiles++].name
4140                   = save_string (argv[i] + prev, j - prev);
4141                 prev = j + 1;
4142               }
4143           /* Record the part after the last comma.  */
4144           infiles[n_infiles].language = "*";
4145           infiles[n_infiles++].name = argv[i] + prev;
4146         }
4147       else if (strcmp (argv[i], "-Xlinker") == 0)
4148         {
4149           infiles[n_infiles].language = "*";
4150           infiles[n_infiles++].name = argv[++i];
4151         }
4152       /* Xassembler and Xpreprocessor were already handled in the first argv
4153          scan, so all we need to do here is ignore them and their argument.  */
4154       else if (strcmp (argv[i], "-Xassembler") == 0)
4155         i++;
4156       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4157         i++;
4158       else if (strcmp (argv[i], "-l") == 0)
4159         { /* POSIX allows separation of -l and the lib arg;
4160              canonicalize by concatenating -l with its arg */
4161           infiles[n_infiles].language = "*";
4162           infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4163         }
4164       else if (strncmp (argv[i], "-l", 2) == 0)
4165         {
4166           infiles[n_infiles].language = "*";
4167           infiles[n_infiles++].name = argv[i];
4168         }
4169       else if (strcmp (argv[i], "-specs") == 0)
4170         i++;
4171       else if (strncmp (argv[i], "-specs=", 7) == 0)
4172         ;
4173       else if (strcmp (argv[i], "-time") == 0)
4174         ;
4175       else if (strcmp (argv[i], "-###") == 0)
4176         ;
4177       else if (argv[i][0] == '-' && argv[i][1] != 0)
4178         {
4179           const char *p = &argv[i][1];
4180           int c = *p;
4181
4182           if (c == 'x')
4183             {
4184               if (p[1] == 0 && i + 1 == argc)
4185                 fatal ("argument to '-x' is missing");
4186               if (p[1] == 0)
4187                 spec_lang = argv[++i];
4188               else
4189                 spec_lang = p + 1;
4190               if (! strcmp (spec_lang, "none"))
4191                 /* Suppress the warning if -xnone comes after the last input
4192                    file, because alternate command interfaces like g++ might
4193                    find it useful to place -xnone after each input file.  */
4194                 spec_lang = 0;
4195               else
4196                 last_language_n_infiles = n_infiles;
4197               continue;
4198             }
4199           switches[n_switches].part1 = p;
4200           /* Deal with option arguments in separate argv elements.  */
4201           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4202               || WORD_SWITCH_TAKES_ARG (p))
4203             {
4204               int j = 0;
4205               int n_args = WORD_SWITCH_TAKES_ARG (p);
4206
4207               if (n_args == 0)
4208                 {
4209                   /* Count only the option arguments in separate argv elements.  */
4210                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4211                 }
4212               if (i + n_args >= argc)
4213                 fatal ("argument to '-%s' is missing", p);
4214               switches[n_switches].args
4215                 = XNEWVEC (const char *, n_args + 1);
4216               while (j < n_args)
4217                 switches[n_switches].args[j++] = argv[++i];
4218               /* Null-terminate the vector.  */
4219               switches[n_switches].args[j] = 0;
4220             }
4221           else if (strchr (switches_need_spaces, c))
4222             {
4223               /* On some systems, ld cannot handle some options without
4224                  a space.  So split the option from its argument.  */
4225               char *part1 = XNEWVEC (char, 2);
4226               part1[0] = c;
4227               part1[1] = '\0';
4228
4229               switches[n_switches].part1 = part1;
4230               switches[n_switches].args = XNEWVEC (const char *, 2);
4231               switches[n_switches].args[0] = xstrdup (p+1);
4232               switches[n_switches].args[1] = 0;
4233             }
4234           else
4235             switches[n_switches].args = 0;
4236
4237           switches[n_switches].live_cond = SWITCH_OK;
4238           switches[n_switches].validated = 0;
4239           switches[n_switches].ordering = 0;
4240           /* These are always valid, since gcc.c itself understands the
4241              first four and gfortranspec.c understands -static-libgfortran.  */
4242           if (!strcmp (p, "save-temps")
4243               || !strcmp (p, "static-libgcc")
4244               || !strcmp (p, "shared-libgcc")
4245               || !strcmp (p, "pipe")
4246               || !strcmp (p, "static-libgfortran"))
4247             switches[n_switches].validated = 1;
4248           else
4249             {
4250               char ch = switches[n_switches].part1[0];
4251               if (ch == 'B')
4252                 switches[n_switches].validated = 1;
4253             }
4254           n_switches++;
4255         }
4256       else
4257         {
4258 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4259           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4260 #endif
4261
4262           if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4263             {
4264               perror_with_name (argv[i]);
4265               error_count++;
4266             }
4267           else
4268             {
4269               infiles[n_infiles].language = spec_lang;
4270               infiles[n_infiles++].name = argv[i];
4271             }
4272         }
4273     }
4274
4275   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4276     error ("warning: '-x %s' after last input file has no effect", spec_lang);
4277
4278   /* Ensure we only invoke each subprocess once.  */
4279   if (print_subprocess_help || print_help_list)
4280     {
4281       n_infiles = 1;
4282
4283       /* Create a dummy input file, so that we can pass
4284          the help option on to the various sub-processes.  */
4285       infiles[0].language = "c";
4286       infiles[0].name   = "help-dummy";
4287     }
4288
4289   switches[n_switches].part1 = 0;
4290   infiles[n_infiles].name = 0;
4291 }
4292
4293 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4294    and place that in the environment.  */
4295
4296 static void
4297 set_collect_gcc_options (void)
4298 {
4299   int i;
4300   int first_time;
4301
4302   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4303      the compiler.  */
4304   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4305                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4306
4307   first_time = TRUE;
4308   for (i = 0; (int) i < n_switches; i++)
4309     {
4310       const char *const *args;
4311       const char *p, *q;
4312       if (!first_time)
4313         obstack_grow (&collect_obstack, " ", 1);
4314
4315       first_time = FALSE;
4316
4317       /* Ignore elided switches.  */
4318       if (switches[i].live_cond == SWITCH_IGNORE)
4319         continue;
4320
4321       obstack_grow (&collect_obstack, "'-", 2);
4322       q = switches[i].part1;
4323       while ((p = strchr (q, '\'')))
4324         {
4325           obstack_grow (&collect_obstack, q, p - q);
4326           obstack_grow (&collect_obstack, "'\\''", 4);
4327           q = ++p;
4328         }
4329       obstack_grow (&collect_obstack, q, strlen (q));
4330       obstack_grow (&collect_obstack, "'", 1);
4331
4332       for (args = switches[i].args; args && *args; args++)
4333         {
4334           obstack_grow (&collect_obstack, " '", 2);
4335           q = *args;
4336           while ((p = strchr (q, '\'')))
4337             {
4338               obstack_grow (&collect_obstack, q, p - q);
4339               obstack_grow (&collect_obstack, "'\\''", 4);
4340               q = ++p;
4341             }
4342           obstack_grow (&collect_obstack, q, strlen (q));
4343           obstack_grow (&collect_obstack, "'", 1);
4344         }
4345     }
4346   obstack_grow (&collect_obstack, "\0", 1);
4347   xputenv (XOBFINISH (&collect_obstack, char *));
4348 }
4349 \f
4350 /* Process a spec string, accumulating and running commands.  */
4351
4352 /* These variables describe the input file name.
4353    input_file_number is the index on outfiles of this file,
4354    so that the output file name can be stored for later use by %o.
4355    input_basename is the start of the part of the input file
4356    sans all directory names, and basename_length is the number
4357    of characters starting there excluding the suffix .c or whatever.  */
4358
4359 static const char *input_filename;
4360 static int input_file_number;
4361 size_t input_filename_length;
4362 static int basename_length;
4363 static int suffixed_basename_length;
4364 static const char *input_basename;
4365 static const char *input_suffix;
4366 #ifndef HOST_LACKS_INODE_NUMBERS
4367 static struct stat input_stat;
4368 #endif
4369 static int input_stat_set;
4370
4371 /* The compiler used to process the current input file.  */
4372 static struct compiler *input_file_compiler;
4373
4374 /* These are variables used within do_spec and do_spec_1.  */
4375
4376 /* Nonzero if an arg has been started and not yet terminated
4377    (with space, tab or newline).  */
4378 static int arg_going;
4379
4380 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4381    is a temporary file name.  */
4382 static int delete_this_arg;
4383
4384 /* Nonzero means %w has been seen; the next arg to be terminated
4385    is the output file name of this compilation.  */
4386 static int this_is_output_file;
4387
4388 /* Nonzero means %s has been seen; the next arg to be terminated
4389    is the name of a library file and we should try the standard
4390    search dirs for it.  */
4391 static int this_is_library_file;
4392
4393 /* Nonzero means that the input of this command is coming from a pipe.  */
4394 static int input_from_pipe;
4395
4396 /* Nonnull means substitute this for any suffix when outputting a switches
4397    arguments.  */
4398 static const char *suffix_subst;
4399
4400 /* If there is an argument being accumulated, terminate it and store it.  */
4401
4402 static void
4403 end_going_arg (void)
4404 {
4405   if (arg_going)
4406     {
4407       const char *string;
4408
4409       obstack_1grow (&obstack, 0);
4410       string = XOBFINISH (&obstack, const char *);
4411       if (this_is_library_file)
4412         string = find_file (string);
4413       store_arg (string, delete_this_arg, this_is_output_file);
4414       if (this_is_output_file)
4415         outfiles[input_file_number] = string;
4416       arg_going = 0;
4417     }
4418 }
4419
4420 /* Process the spec SPEC and run the commands specified therein.
4421    Returns 0 if the spec is successfully processed; -1 if failed.  */
4422
4423 int
4424 do_spec (const char *spec)
4425 {
4426   int value;
4427
4428   value = do_spec_2 (spec);
4429
4430   /* Force out any unfinished command.
4431      If -pipe, this forces out the last command if it ended in `|'.  */
4432   if (value == 0)
4433     {
4434       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4435         argbuf_index--;
4436
4437       set_collect_gcc_options ();
4438
4439       if (argbuf_index > 0)
4440         value = execute ();
4441     }
4442
4443   return value;
4444 }
4445
4446 static int
4447 do_spec_2 (const char *spec)
4448 {
4449   int result;
4450
4451   clear_args ();
4452   arg_going = 0;
4453   delete_this_arg = 0;
4454   this_is_output_file = 0;
4455   this_is_library_file = 0;
4456   input_from_pipe = 0;
4457   suffix_subst = NULL;
4458
4459   result = do_spec_1 (spec, 0, NULL);
4460
4461   end_going_arg ();
4462
4463   return result;
4464 }
4465
4466
4467 /* Process the given spec string and add any new options to the end
4468    of the switches/n_switches array.  */
4469
4470 static void
4471 do_option_spec (const char *name, const char *spec)
4472 {
4473   unsigned int i, value_count, value_len;
4474   const char *p, *q, *value;
4475   char *tmp_spec, *tmp_spec_p;
4476
4477   if (configure_default_options[0].name == NULL)
4478     return;
4479
4480   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4481     if (strcmp (configure_default_options[i].name, name) == 0)
4482       break;
4483   if (i == ARRAY_SIZE (configure_default_options))
4484     return;
4485
4486   value = configure_default_options[i].value;
4487   value_len = strlen (value);
4488
4489   /* Compute the size of the final spec.  */
4490   value_count = 0;
4491   p = spec;
4492   while ((p = strstr (p, "%(VALUE)")) != NULL)
4493     {
4494       p ++;
4495       value_count ++;
4496     }
4497
4498   /* Replace each %(VALUE) by the specified value.  */
4499   tmp_spec = alloca (strlen (spec) + 1
4500                      + value_count * (value_len - strlen ("%(VALUE)")));
4501   tmp_spec_p = tmp_spec;
4502   q = spec;
4503   while ((p = strstr (q, "%(VALUE)")) != NULL)
4504     {
4505       memcpy (tmp_spec_p, q, p - q);
4506       tmp_spec_p = tmp_spec_p + (p - q);
4507       memcpy (tmp_spec_p, value, value_len);
4508       tmp_spec_p += value_len;
4509       q = p + strlen ("%(VALUE)");
4510     }
4511   strcpy (tmp_spec_p, q);
4512
4513   do_self_spec (tmp_spec);
4514 }
4515
4516 /* Process the given spec string and add any new options to the end
4517    of the switches/n_switches array.  */
4518
4519 static void
4520 do_self_spec (const char *spec)
4521 {
4522   do_spec_2 (spec);
4523   do_spec_1 (" ", 0, NULL);
4524
4525   if (argbuf_index > 0)
4526     {
4527       int i, first;
4528
4529       first = n_switches;
4530       n_switches += argbuf_index;
4531       switches = xrealloc (switches,
4532                            sizeof (struct switchstr) * (n_switches + 1));
4533
4534       switches[n_switches] = switches[first];
4535       for (i = 0; i < argbuf_index; i++)
4536         {
4537           struct switchstr *sw;
4538
4539           /* Each switch should start with '-'.  */
4540           if (argbuf[i][0] != '-')
4541             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4542
4543           sw = &switches[i + first];
4544           sw->part1 = &argbuf[i][1];
4545           sw->args = 0;
4546           sw->live_cond = SWITCH_OK;
4547           sw->validated = 0;
4548           sw->ordering = 0;
4549         }
4550     }
4551 }
4552
4553 /* Callback for processing %D and %I specs.  */
4554
4555 struct spec_path_info {
4556   const char *option;
4557   const char *append;
4558   size_t append_len;
4559   bool omit_relative;
4560   bool separate_options;
4561 };
4562
4563 static void *
4564 spec_path (char *path, void *data)
4565 {
4566   struct spec_path_info *info = data;
4567   size_t len = 0;
4568   char save = 0;
4569
4570   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4571     return NULL;
4572
4573   if (info->append_len != 0)
4574     {
4575       len = strlen (path);
4576       memcpy (path + len, info->append, info->append_len + 1);
4577     }
4578
4579   if (!is_directory (path, true))
4580     return NULL;
4581
4582   do_spec_1 (info->option, 1, NULL);
4583   if (info->separate_options)
4584     do_spec_1 (" ", 0, NULL);
4585
4586   if (info->append_len == 0)
4587     {
4588       len = strlen (path);
4589       save = path[len - 1];
4590       if (IS_DIR_SEPARATOR (path[len - 1]))
4591         path[len - 1] = '\0';
4592     }
4593
4594   do_spec_1 (path, 1, NULL);
4595   do_spec_1 (" ", 0, NULL);
4596
4597   /* Must not damage the original path.  */
4598   if (info->append_len == 0)
4599     path[len - 1] = save;
4600
4601   return NULL;
4602 }
4603
4604 /* Process the sub-spec SPEC as a portion of a larger spec.
4605    This is like processing a whole spec except that we do
4606    not initialize at the beginning and we do not supply a
4607    newline by default at the end.
4608    INSWITCH nonzero means don't process %-sequences in SPEC;
4609    in this case, % is treated as an ordinary character.
4610    This is used while substituting switches.
4611    INSWITCH nonzero also causes SPC not to terminate an argument.
4612
4613    Value is zero unless a line was finished
4614    and the command on that line reported an error.  */
4615
4616 static int
4617 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4618 {
4619   const char *p = spec;
4620   int c;
4621   int i;
4622   int value;
4623
4624   while ((c = *p++))
4625     /* If substituting a switch, treat all chars like letters.
4626        Otherwise, NL, SPC, TAB and % are special.  */
4627     switch (inswitch ? 'a' : c)
4628       {
4629       case '\n':
4630         end_going_arg ();
4631
4632         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4633           {
4634             /* A `|' before the newline means use a pipe here,
4635                but only if -pipe was specified.
4636                Otherwise, execute now and don't pass the `|' as an arg.  */
4637             if (use_pipes)
4638               {
4639                 input_from_pipe = 1;
4640                 break;
4641               }
4642             else
4643               argbuf_index--;
4644           }
4645
4646         set_collect_gcc_options ();
4647
4648         if (argbuf_index > 0)
4649           {
4650             value = execute ();
4651             if (value)
4652               return value;
4653           }
4654         /* Reinitialize for a new command, and for a new argument.  */
4655         clear_args ();
4656         arg_going = 0;
4657         delete_this_arg = 0;
4658         this_is_output_file = 0;
4659         this_is_library_file = 0;
4660         input_from_pipe = 0;
4661         break;
4662
4663       case '|':
4664         end_going_arg ();
4665
4666         /* Use pipe */
4667         obstack_1grow (&obstack, c);
4668         arg_going = 1;
4669         break;
4670
4671       case '\t':
4672       case ' ':
4673         end_going_arg ();
4674
4675         /* Reinitialize for a new argument.  */
4676         delete_this_arg = 0;
4677         this_is_output_file = 0;
4678         this_is_library_file = 0;
4679         break;
4680
4681       case '%':
4682         switch (c = *p++)
4683           {
4684           case 0:
4685             fatal ("spec '%s' invalid", spec);
4686
4687           case 'b':
4688             obstack_grow (&obstack, input_basename, basename_length);
4689             arg_going = 1;
4690             break;
4691
4692           case 'B':
4693             obstack_grow (&obstack, input_basename, suffixed_basename_length);
4694             arg_going = 1;
4695             break;
4696
4697           case 'd':
4698             delete_this_arg = 2;
4699             break;
4700
4701           /* Dump out the directories specified with LIBRARY_PATH,
4702              followed by the absolute directories
4703              that we search for startfiles.  */
4704           case 'D':
4705             {
4706               struct spec_path_info info;
4707
4708               info.option = "-L";
4709               info.append_len = 0;
4710 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4711               /* Used on systems which record the specified -L dirs
4712                  and use them to search for dynamic linking.
4713                  Relative directories always come from -B,
4714                  and it is better not to use them for searching
4715                  at run time.  In particular, stage1 loses.  */
4716               info.omit_relative = true;
4717 #else
4718               info.omit_relative = false;
4719 #endif
4720               info.separate_options = false;
4721
4722               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4723             }
4724             break;
4725
4726           case 'e':
4727             /* %efoo means report an error with `foo' as error message
4728                and don't execute any more commands for this file.  */
4729             {
4730               const char *q = p;
4731               char *buf;
4732               while (*p != 0 && *p != '\n')
4733                 p++;
4734               buf = alloca (p - q + 1);
4735               strncpy (buf, q, p - q);
4736               buf[p - q] = 0;
4737               error ("%s", buf);
4738               return -1;
4739             }
4740             break;
4741           case 'n':
4742             /* %nfoo means report a notice with `foo' on stderr.  */
4743             {
4744               const char *q = p;
4745               char *buf;
4746               while (*p != 0 && *p != '\n')
4747                 p++;
4748               buf = alloca (p - q + 1);
4749               strncpy (buf, q, p - q);
4750               buf[p - q] = 0;
4751               notice ("%s\n", buf);
4752               if (*p)
4753                 p++;
4754             }
4755             break;
4756
4757           case 'j':
4758             {
4759               struct stat st;
4760
4761               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4762                  defined, and it is not a directory, and it is
4763                  writable, use it.  Otherwise, treat this like any
4764                  other temporary file.  */
4765
4766               if ((!save_temps_flag)
4767                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4768                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4769                 {
4770                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4771                                 strlen (HOST_BIT_BUCKET));
4772                   delete_this_arg = 0;
4773                   arg_going = 1;
4774                   break;
4775                 }
4776             }
4777             goto create_temp_file;
4778           case '|':
4779             if (use_pipes)
4780               {
4781                 obstack_1grow (&obstack, '-');
4782                 delete_this_arg = 0;
4783                 arg_going = 1;
4784
4785                 /* consume suffix */
4786                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4787                   p++;
4788                 if (p[0] == '%' && p[1] == 'O')
4789                   p += 2;
4790
4791                 break;
4792               }
4793             goto create_temp_file;
4794           case 'm':
4795             if (use_pipes)
4796               {
4797                 /* consume suffix */
4798                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4799                   p++;
4800                 if (p[0] == '%' && p[1] == 'O')
4801                   p += 2;
4802
4803                 break;
4804               }
4805             goto create_temp_file;
4806           case 'g':
4807           case 'u':
4808           case 'U':
4809           create_temp_file:
4810               {
4811                 struct temp_name *t;
4812                 int suffix_length;
4813                 const char *suffix = p;
4814                 char *saved_suffix = NULL;
4815
4816                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4817                   p++;
4818                 suffix_length = p - suffix;
4819                 if (p[0] == '%' && p[1] == 'O')
4820                   {
4821                     p += 2;
4822                     /* We don't support extra suffix characters after %O.  */
4823                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4824                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
4825                     if (suffix_length == 0)
4826                       suffix = TARGET_OBJECT_SUFFIX;
4827                     else
4828                       {
4829                         saved_suffix
4830                           = XNEWVEC (char, suffix_length
4831                                      + strlen (TARGET_OBJECT_SUFFIX));
4832                         strncpy (saved_suffix, suffix, suffix_length);
4833                         strcpy (saved_suffix + suffix_length,
4834                                 TARGET_OBJECT_SUFFIX);
4835                       }
4836                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4837                   }
4838
4839                 /* If the input_filename has the same suffix specified
4840                    for the %g, %u, or %U, and -save-temps is specified,
4841                    we could end up using that file as an intermediate
4842                    thus clobbering the user's source file (.e.g.,
4843                    gcc -save-temps foo.s would clobber foo.s with the
4844                    output of cpp0).  So check for this condition and
4845                    generate a temp file as the intermediate.  */
4846
4847                 if (save_temps_flag)
4848                   {
4849                     char *tmp;
4850
4851                     temp_filename_length = basename_length + suffix_length;
4852                     tmp = alloca (temp_filename_length + 1);
4853                     strncpy (tmp, input_basename, basename_length);
4854                     strncpy (tmp + basename_length, suffix, suffix_length);
4855                     tmp[temp_filename_length] = '\0';
4856                     temp_filename = tmp;
4857                     if (strcmp (temp_filename, input_filename) != 0)
4858                       {
4859 #ifndef HOST_LACKS_INODE_NUMBERS
4860                         struct stat st_temp;
4861
4862                         /* Note, set_input() resets input_stat_set to 0.  */
4863                         if (input_stat_set == 0)
4864                           {
4865                             input_stat_set = stat (input_filename, &input_stat);
4866                             if (input_stat_set >= 0)
4867                               input_stat_set = 1;
4868                           }
4869
4870                         /* If we have the stat for the input_filename
4871                            and we can do the stat for the temp_filename
4872                            then the they could still refer to the same
4873                            file if st_dev/st_ino's are the same.  */
4874                         if (input_stat_set != 1
4875                             || stat (temp_filename, &st_temp) < 0
4876                             || input_stat.st_dev != st_temp.st_dev
4877                             || input_stat.st_ino != st_temp.st_ino)
4878 #else
4879                         /* Just compare canonical pathnames.  */
4880                         char* input_realname = lrealpath (input_filename);
4881                         char* temp_realname = lrealpath (temp_filename);
4882                         bool files_differ = strcmp (input_realname, temp_realname);
4883                         free (input_realname);
4884                         free (temp_realname);
4885                         if (files_differ)
4886 #endif
4887                           {
4888                             temp_filename = save_string (temp_filename,
4889                                                          temp_filename_length + 1);
4890                             obstack_grow (&obstack, temp_filename,
4891                                                     temp_filename_length);
4892                             arg_going = 1;
4893                             delete_this_arg = 0;
4894                             break;
4895                           }
4896                       }
4897                   }
4898
4899                 /* See if we already have an association of %g/%u/%U and
4900                    suffix.  */
4901                 for (t = temp_names; t; t = t->next)
4902                   if (t->length == suffix_length
4903                       && strncmp (t->suffix, suffix, suffix_length) == 0
4904                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4905                     break;
4906
4907                 /* Make a new association if needed.  %u and %j
4908                    require one.  */
4909                 if (t == 0 || c == 'u' || c == 'j')
4910                   {
4911                     if (t == 0)
4912                       {
4913                         t = xmalloc (sizeof (struct temp_name));
4914                         t->next = temp_names;
4915                         temp_names = t;
4916                       }
4917                     t->length = suffix_length;
4918                     if (saved_suffix)
4919                       {
4920                         t->suffix = saved_suffix;
4921                         saved_suffix = NULL;
4922                       }
4923                     else
4924                       t->suffix = save_string (suffix, suffix_length);
4925                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4926                     temp_filename = make_temp_file (t->suffix);
4927                     temp_filename_length = strlen (temp_filename);
4928                     t->filename = temp_filename;
4929                     t->filename_length = temp_filename_length;
4930                   }
4931
4932                 if (saved_suffix)
4933                   free (saved_suffix);
4934
4935                 obstack_grow (&obstack, t->filename, t->filename_length);
4936                 delete_this_arg = 1;
4937               }
4938             arg_going = 1;
4939             break;
4940
4941           case 'i':
4942             if (combine_inputs)
4943               {
4944                 for (i = 0; (int) i < n_infiles; i++)
4945                   if ((!infiles[i].language) || (infiles[i].language[0] != '*'))
4946                     if (infiles[i].incompiler == input_file_compiler)
4947                       {
4948                         store_arg (infiles[i].name, 0, 0);
4949                         infiles[i].compiled = true;
4950                       }
4951               }
4952             else
4953               {
4954                 obstack_grow (&obstack, input_filename, input_filename_length);
4955                 arg_going = 1;
4956               }
4957             break;
4958
4959           case 'I':
4960             {
4961               struct spec_path_info info;
4962
4963               if (multilib_dir)
4964                 {
4965                   do_spec_1 ("-imultilib", 1, NULL);
4966                   /* Make this a separate argument.  */
4967                   do_spec_1 (" ", 0, NULL);
4968                   do_spec_1 (multilib_dir, 1, NULL);
4969                   do_spec_1 (" ", 0, NULL);
4970                 }
4971
4972               if (gcc_exec_prefix)
4973                 {
4974                   do_spec_1 ("-iprefix", 1, NULL);
4975                   /* Make this a separate argument.  */
4976                   do_spec_1 (" ", 0, NULL);
4977                   do_spec_1 (gcc_exec_prefix, 1, NULL);
4978                   do_spec_1 (" ", 0, NULL);
4979                 }
4980
4981               if (target_system_root_changed ||
4982                   (target_system_root && target_sysroot_hdrs_suffix))
4983                 {
4984                   do_spec_1 ("-isysroot", 1, NULL);
4985                   /* Make this a separate argument.  */
4986                   do_spec_1 (" ", 0, NULL);
4987                   do_spec_1 (target_system_root, 1, NULL);
4988                   if (target_sysroot_hdrs_suffix)
4989                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4990                   do_spec_1 (" ", 0, NULL);
4991                 }
4992
4993               info.option = "-isystem";
4994               info.append = "include";
4995               info.append_len = strlen (info.append);
4996               info.omit_relative = false;
4997               info.separate_options = true;
4998
4999               for_each_path (&include_prefixes, false, info.append_len,
5000                              spec_path, &info);
5001
5002               info.append = "include-fixed";
5003               if (*sysroot_hdrs_suffix_spec)
5004                 info.append = concat (info.append, dir_separator_str,
5005                                       multilib_dir, NULL);
5006               info.append_len = strlen (info.append);
5007               for_each_path (&include_prefixes, false, info.append_len,
5008                              spec_path, &info);
5009             }
5010             break;
5011
5012           case 'o':
5013             {
5014               int max = n_infiles;
5015               max += lang_specific_extra_outfiles;
5016
5017               if (HAVE_GNU_LD && at_file_supplied)
5018                 {
5019                   /* We are going to expand `%o' to `@FILE', where FILE
5020                      is a newly-created temporary filename.  The filenames
5021                      that would usually be expanded in place of %o will be
5022                      written to the temporary file.  */
5023
5024                   char *temp_file = make_temp_file ("");
5025                   char *at_argument;
5026                   char **argv;
5027                   int n_files, j, status;
5028                   FILE *f;
5029
5030                   at_argument = concat ("@", temp_file, NULL);
5031                   store_arg (at_argument, 0, 0);
5032
5033                   /* Convert OUTFILES into a form suitable for writeargv.  */
5034
5035                   /* Determine how many are non-NULL.  */
5036                   for (n_files = 0, i = 0; i < max; i++)
5037                     n_files += outfiles[i] != NULL;
5038
5039                   argv = alloca (sizeof (char *) * (n_files + 1));
5040
5041                   /* Copy the strings over.  */
5042                   for (i = 0, j = 0; i < max; i++)
5043                     if (outfiles[i])
5044                       {
5045                         argv[j] = CONST_CAST (char *, outfiles[i]);
5046                         j++;
5047                       }
5048                   argv[j] = NULL;
5049
5050                   f = fopen (temp_file, "w");
5051
5052                   if (f == NULL)
5053                     fatal ("could not open temporary response file %s",
5054                            temp_file);
5055
5056                   status = writeargv (argv, f);
5057
5058                   if (status)
5059                     fatal ("could not write to temporary response file %s",
5060                            temp_file);
5061
5062                   status = fclose (f);
5063
5064                   if (EOF == status)
5065                     fatal ("could not close temporary response file %s",
5066                            temp_file);
5067
5068                   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5069                 }
5070               else
5071                 for (i = 0; i < max; i++)
5072                   if (outfiles[i])
5073                     store_arg (outfiles[i], 0, 0);
5074               break;
5075             }
5076
5077           case 'O':
5078             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5079             arg_going = 1;
5080             break;
5081
5082           case 's':
5083             this_is_library_file = 1;
5084             break;
5085
5086           case 'V':
5087             outfiles[input_file_number] = NULL;
5088             break;
5089
5090           case 'w':
5091             this_is_output_file = 1;
5092             break;
5093
5094           case 'W':
5095             {
5096               int cur_index = argbuf_index;
5097               /* Handle the {...} following the %W.  */
5098               if (*p != '{')
5099                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5100               p = handle_braces (p + 1);
5101               if (p == 0)
5102                 return -1;
5103               end_going_arg ();
5104               /* If any args were output, mark the last one for deletion
5105                  on failure.  */
5106               if (argbuf_index != cur_index)
5107                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5108               break;
5109             }
5110
5111           /* %x{OPTION} records OPTION for %X to output.  */
5112           case 'x':
5113             {
5114               const char *p1 = p;
5115               char *string;
5116
5117               /* Skip past the option value and make a copy.  */
5118               if (*p != '{')
5119                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5120               while (*p++ != '}')
5121                 ;
5122               string = save_string (p1 + 1, p - p1 - 2);
5123
5124               /* See if we already recorded this option.  */
5125               for (i = 0; i < n_linker_options; i++)
5126                 if (! strcmp (string, linker_options[i]))
5127                   {
5128                     free (string);
5129                     return 0;
5130                   }
5131
5132               /* This option is new; add it.  */
5133               add_linker_option (string, strlen (string));
5134             }
5135             break;
5136
5137           /* Dump out the options accumulated previously using %x.  */
5138           case 'X':
5139             for (i = 0; i < n_linker_options; i++)
5140               {
5141                 do_spec_1 (linker_options[i], 1, NULL);
5142                 /* Make each accumulated option a separate argument.  */
5143                 do_spec_1 (" ", 0, NULL);
5144               }
5145             break;
5146
5147           /* Dump out the options accumulated previously using -Wa,.  */
5148           case 'Y':
5149             for (i = 0; i < n_assembler_options; i++)
5150               {
5151                 do_spec_1 (assembler_options[i], 1, NULL);
5152                 /* Make each accumulated option a separate argument.  */
5153                 do_spec_1 (" ", 0, NULL);
5154               }
5155             break;
5156
5157           /* Dump out the options accumulated previously using -Wp,.  */
5158           case 'Z':
5159             for (i = 0; i < n_preprocessor_options; i++)
5160               {
5161                 do_spec_1 (preprocessor_options[i], 1, NULL);
5162                 /* Make each accumulated option a separate argument.  */
5163                 do_spec_1 (" ", 0, NULL);
5164               }
5165             break;
5166
5167             /* Here are digits and numbers that just process
5168                a certain constant string as a spec.  */
5169
5170           case '1':
5171             value = do_spec_1 (cc1_spec, 0, NULL);
5172             if (value != 0)
5173               return value;
5174             break;
5175
5176           case '2':
5177             value = do_spec_1 (cc1plus_spec, 0, NULL);
5178             if (value != 0)
5179               return value;
5180             break;
5181
5182           case 'a':
5183             value = do_spec_1 (asm_spec, 0, NULL);
5184             if (value != 0)
5185               return value;
5186             break;
5187
5188           case 'A':
5189             value = do_spec_1 (asm_final_spec, 0, NULL);
5190             if (value != 0)
5191               return value;
5192             break;
5193
5194           case 'C':
5195             {
5196               const char *const spec
5197                 = (input_file_compiler->cpp_spec
5198                    ? input_file_compiler->cpp_spec
5199                    : cpp_spec);
5200               value = do_spec_1 (spec, 0, NULL);
5201               if (value != 0)
5202                 return value;
5203             }
5204             break;
5205
5206           case 'E':
5207             value = do_spec_1 (endfile_spec, 0, NULL);
5208             if (value != 0)
5209               return value;
5210             break;
5211
5212           case 'l':
5213             value = do_spec_1 (link_spec, 0, NULL);
5214             if (value != 0)
5215               return value;
5216             break;
5217
5218           case 'L':
5219             value = do_spec_1 (lib_spec, 0, NULL);
5220             if (value != 0)
5221               return value;
5222             break;
5223
5224           case 'G':
5225             value = do_spec_1 (libgcc_spec, 0, NULL);
5226             if (value != 0)
5227               return value;
5228             break;
5229
5230           case 'R':
5231             /* We assume there is a directory
5232                separator at the end of this string.  */
5233             if (target_system_root)
5234               {
5235                 obstack_grow (&obstack, target_system_root,
5236                               strlen (target_system_root));
5237                 if (target_sysroot_suffix)
5238                   obstack_grow (&obstack, target_sysroot_suffix,
5239                                 strlen (target_sysroot_suffix));
5240               }
5241             break;
5242
5243           case 'S':
5244             value = do_spec_1 (startfile_spec, 0, NULL);
5245             if (value != 0)
5246               return value;
5247             break;
5248
5249             /* Here we define characters other than letters and digits.  */
5250
5251           case '{':
5252             p = handle_braces (p);
5253             if (p == 0)
5254               return -1;
5255             break;
5256
5257           case ':':
5258             p = handle_spec_function (p);
5259             if (p == 0)
5260               return -1;
5261             break;
5262
5263           case '%':
5264             obstack_1grow (&obstack, '%');
5265             break;
5266
5267           case '.':
5268             {
5269               unsigned len = 0;
5270
5271               while (p[len] && p[len] != ' ' && p[len] != '%')
5272                 len++;
5273               suffix_subst = save_string (p - 1, len + 1);
5274               p += len;
5275             }
5276            break;
5277
5278            /* Henceforth ignore the option(s) matching the pattern
5279               after the %<.  */
5280           case '<':
5281             {
5282               unsigned len = 0;
5283               int have_wildcard = 0;
5284               int i;
5285
5286               while (p[len] && p[len] != ' ' && p[len] != '\t')
5287                 len++;
5288
5289               if (p[len-1] == '*')
5290                 have_wildcard = 1;
5291
5292               for (i = 0; i < n_switches; i++)
5293                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5294                     && (have_wildcard || switches[i].part1[len] == '\0'))
5295                   {
5296                     switches[i].live_cond = SWITCH_IGNORE;
5297                     switches[i].validated = 1;
5298                   }
5299
5300               p += len;
5301             }
5302             break;
5303
5304           case '*':
5305             if (soft_matched_part)
5306               {
5307                 do_spec_1 (soft_matched_part, 1, NULL);
5308                 do_spec_1 (" ", 0, NULL);
5309               }
5310             else
5311               /* Catch the case where a spec string contains something like
5312                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5313                  hand side of the :.  */
5314               error ("spec failure: '%%*' has not been initialized by pattern match");
5315             break;
5316
5317             /* Process a string found as the value of a spec given by name.
5318                This feature allows individual machine descriptions
5319                to add and use their own specs.
5320                %[...] modifies -D options the way %P does;
5321                %(...) uses the spec unmodified.  */
5322           case '[':
5323             error ("warning: use of obsolete %%[ operator in specs");
5324           case '(':
5325             {
5326               const char *name = p;
5327               struct spec_list *sl;
5328               int len;
5329
5330               /* The string after the S/P is the name of a spec that is to be
5331                  processed.  */
5332               while (*p && *p != ')' && *p != ']')
5333                 p++;
5334
5335               /* See if it's in the list.  */
5336               for (len = p - name, sl = specs; sl; sl = sl->next)
5337                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5338                   {
5339                     name = *(sl->ptr_spec);
5340 #ifdef DEBUG_SPECS
5341                     notice ("Processing spec %c%s%c, which is '%s'\n",
5342                             c, sl->name, (c == '(') ? ')' : ']', name);
5343 #endif
5344                     break;
5345                   }
5346
5347               if (sl)
5348                 {
5349                   if (c == '(')
5350                     {
5351                       value = do_spec_1 (name, 0, NULL);
5352                       if (value != 0)
5353                         return value;
5354                     }
5355                   else
5356                     {
5357                       char *x = alloca (strlen (name) * 2 + 1);
5358                       char *buf = x;
5359                       const char *y = name;
5360                       int flag = 0;
5361
5362                       /* Copy all of NAME into BUF, but put __ after
5363                          every -D and at the end of each arg.  */
5364                       while (1)
5365                         {
5366                           if (! strncmp (y, "-D", 2))
5367                             {
5368                               *x++ = '-';
5369                               *x++ = 'D';
5370                               *x++ = '_';
5371                               *x++ = '_';
5372                               y += 2;
5373                               flag = 1;
5374                               continue;
5375                             }
5376                           else if (flag
5377                                    && (*y == ' ' || *y == '\t' || *y == '='
5378                                        || *y == '}' || *y == 0))
5379                             {
5380                               *x++ = '_';
5381                               *x++ = '_';
5382                               flag = 0;
5383                             }
5384                           if (*y == 0)
5385                             break;
5386                           else
5387                             *x++ = *y++;
5388                         }
5389                       *x = 0;
5390
5391                       value = do_spec_1 (buf, 0, NULL);
5392                       if (value != 0)
5393                         return value;
5394                     }
5395                 }
5396
5397               /* Discard the closing paren or bracket.  */
5398               if (*p)
5399                 p++;
5400             }
5401             break;
5402
5403           default:
5404             error ("spec failure: unrecognized spec option '%c'", c);
5405             break;
5406           }
5407         break;
5408
5409       case '\\':
5410         /* Backslash: treat next character as ordinary.  */
5411         c = *p++;
5412
5413         /* Fall through.  */
5414       default:
5415         /* Ordinary character: put it into the current argument.  */
5416         obstack_1grow (&obstack, c);
5417         arg_going = 1;
5418       }
5419
5420   /* End of string.  If we are processing a spec function, we need to
5421      end any pending argument.  */
5422   if (processing_spec_function)
5423     end_going_arg ();
5424
5425   return 0;
5426 }
5427
5428 /* Look up a spec function.  */
5429
5430 static const struct spec_function *
5431 lookup_spec_function (const char *name)
5432 {
5433   const struct spec_function *sf;
5434
5435   for (sf = static_spec_functions; sf->name != NULL; sf++)
5436     if (strcmp (sf->name, name) == 0)
5437       return sf;
5438
5439   return NULL;
5440 }
5441
5442 /* Evaluate a spec function.  */
5443
5444 static const char *
5445 eval_spec_function (const char *func, const char *args)
5446 {
5447   const struct spec_function *sf;
5448   const char *funcval;
5449
5450   /* Saved spec processing context.  */
5451   int save_argbuf_index;
5452   int save_argbuf_length;
5453   const char **save_argbuf;
5454
5455   int save_arg_going;
5456   int save_delete_this_arg;
5457   int save_this_is_output_file;
5458   int save_this_is_library_file;
5459   int save_input_from_pipe;
5460   const char *save_suffix_subst;
5461
5462
5463   sf = lookup_spec_function (func);
5464   if (sf == NULL)
5465     fatal ("unknown spec function '%s'", func);
5466
5467   /* Push the spec processing context.  */
5468   save_argbuf_index = argbuf_index;
5469   save_argbuf_length = argbuf_length;
5470   save_argbuf = argbuf;
5471
5472   save_arg_going = arg_going;
5473   save_delete_this_arg = delete_this_arg;
5474   save_this_is_output_file = this_is_output_file;
5475   save_this_is_library_file = this_is_library_file;
5476   save_input_from_pipe = input_from_pipe;
5477   save_suffix_subst = suffix_subst;
5478
5479   /* Create a new spec processing context, and build the function
5480      arguments.  */
5481
5482   alloc_args ();
5483   if (do_spec_2 (args) < 0)
5484     fatal ("error in args to spec function '%s'", func);
5485
5486   /* argbuf_index is an index for the next argument to be inserted, and
5487      so contains the count of the args already inserted.  */
5488
5489   funcval = (*sf->func) (argbuf_index, argbuf);
5490
5491   /* Pop the spec processing context.  */
5492   argbuf_index = save_argbuf_index;
5493   argbuf_length = save_argbuf_length;
5494   free (argbuf);
5495   argbuf = save_argbuf;
5496
5497   arg_going = save_arg_going;
5498   delete_this_arg = save_delete_this_arg;
5499   this_is_output_file = save_this_is_output_file;
5500   this_is_library_file = save_this_is_library_file;
5501   input_from_pipe = save_input_from_pipe;
5502   suffix_subst = save_suffix_subst;
5503
5504   return funcval;
5505 }
5506
5507 /* Handle a spec function call of the form:
5508
5509    %:function(args)
5510
5511    ARGS is processed as a spec in a separate context and split into an
5512    argument vector in the normal fashion.  The function returns a string
5513    containing a spec which we then process in the caller's context, or
5514    NULL if no processing is required.  */
5515
5516 static const char *
5517 handle_spec_function (const char *p)
5518 {
5519   char *func, *args;
5520   const char *endp, *funcval;
5521   int count;
5522
5523   processing_spec_function++;
5524
5525   /* Get the function name.  */
5526   for (endp = p; *endp != '\0'; endp++)
5527     {
5528       if (*endp == '(')         /* ) */
5529         break;
5530       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5531       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5532         fatal ("malformed spec function name");
5533     }
5534   if (*endp != '(')             /* ) */
5535     fatal ("no arguments for spec function");
5536   func = save_string (p, endp - p);
5537   p = ++endp;
5538
5539   /* Get the arguments.  */
5540   for (count = 0; *endp != '\0'; endp++)
5541     {
5542       /* ( */
5543       if (*endp == ')')
5544         {
5545           if (count == 0)
5546             break;
5547           count--;
5548         }
5549       else if (*endp == '(')    /* ) */
5550         count++;
5551     }
5552   /* ( */
5553   if (*endp != ')')
5554     fatal ("malformed spec function arguments");
5555   args = save_string (p, endp - p);
5556   p = ++endp;
5557
5558   /* p now points to just past the end of the spec function expression.  */
5559
5560   funcval = eval_spec_function (func, args);
5561   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5562     p = NULL;
5563
5564   free (func);
5565   free (args);
5566
5567   processing_spec_function--;
5568
5569   return p;
5570 }
5571
5572 /* Inline subroutine of handle_braces.  Returns true if the current
5573    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5574 static inline bool
5575 input_suffix_matches (const char *atom, const char *end_atom)
5576 {
5577   return (input_suffix
5578           && !strncmp (input_suffix, atom, end_atom - atom)
5579           && input_suffix[end_atom - atom] == '\0');
5580 }
5581
5582 /* Subroutine of handle_braces.  Returns true if the current
5583    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
5584 static bool
5585 input_spec_matches (const char *atom, const char *end_atom)
5586 {
5587   return (input_file_compiler
5588           && input_file_compiler->suffix
5589           && input_file_compiler->suffix[0] != '\0'
5590           && !strncmp (input_file_compiler->suffix + 1, atom,
5591                        end_atom - atom)
5592           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5593 }
5594
5595 /* Subroutine of handle_braces.  Returns true if a switch
5596    matching the atom bracketed by ATOM and END_ATOM appeared on the
5597    command line.  */
5598 static bool
5599 switch_matches (const char *atom, const char *end_atom, int starred)
5600 {
5601   int i;
5602   int len = end_atom - atom;
5603   int plen = starred ? len : -1;
5604
5605   for (i = 0; i < n_switches; i++)
5606     if (!strncmp (switches[i].part1, atom, len)
5607         && (starred || switches[i].part1[len] == '\0')
5608         && check_live_switch (i, plen))
5609       return true;
5610
5611   return false;
5612 }
5613
5614 /* Inline subroutine of handle_braces.  Mark all of the switches which
5615    match ATOM (extends to END_ATOM; STARRED indicates whether there
5616    was a star after the atom) for later processing.  */
5617 static inline void
5618 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5619 {
5620   int i;
5621   int len = end_atom - atom;
5622   int plen = starred ? len : -1;
5623
5624   for (i = 0; i < n_switches; i++)
5625     if (!strncmp (switches[i].part1, atom, len)
5626         && (starred || switches[i].part1[len] == '\0')
5627         && check_live_switch (i, plen))
5628       switches[i].ordering = 1;
5629 }
5630
5631 /* Inline subroutine of handle_braces.  Process all the currently
5632    marked switches through give_switch, and clear the marks.  */
5633 static inline void
5634 process_marked_switches (void)
5635 {
5636   int i;
5637
5638   for (i = 0; i < n_switches; i++)
5639     if (switches[i].ordering == 1)
5640       {
5641         switches[i].ordering = 0;
5642         give_switch (i, 0);
5643       }
5644 }
5645
5646 /* Handle a %{ ... } construct.  P points just inside the leading {.
5647    Returns a pointer one past the end of the brace block, or 0
5648    if we call do_spec_1 and that returns -1.  */
5649
5650 static const char *
5651 handle_braces (const char *p)
5652 {
5653   const char *atom, *end_atom;
5654   const char *d_atom = NULL, *d_end_atom = NULL;
5655   const char *orig = p;
5656
5657   bool a_is_suffix;
5658   bool a_is_spectype;
5659   bool a_is_starred;
5660   bool a_is_negated;
5661   bool a_matched;
5662
5663   bool a_must_be_last = false;
5664   bool ordered_set    = false;
5665   bool disjunct_set   = false;
5666   bool disj_matched   = false;
5667   bool disj_starred   = true;
5668   bool n_way_choice   = false;
5669   bool n_way_matched  = false;
5670
5671 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5672
5673   do
5674     {
5675       if (a_must_be_last)
5676         goto invalid;
5677
5678       /* Scan one "atom" (S in the description above of %{}, possibly
5679          with '!', '.', '@', ',', or '*' modifiers).  */
5680       a_matched = false;
5681       a_is_suffix = false;
5682       a_is_starred = false;
5683       a_is_negated = false;
5684       a_is_spectype = false;
5685
5686       SKIP_WHITE();
5687       if (*p == '!')
5688         p++, a_is_negated = true;
5689
5690       SKIP_WHITE();
5691       if (*p == '.')
5692         p++, a_is_suffix = true;
5693       else if (*p == ',')
5694         p++, a_is_spectype = true;
5695
5696       atom = p;
5697       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5698              || *p == ',' || *p == '.' || *p == '@')
5699         p++;
5700       end_atom = p;
5701
5702       if (*p == '*')
5703         p++, a_is_starred = 1;
5704
5705       SKIP_WHITE();
5706       switch (*p)
5707         {
5708         case '&': case '}':
5709           /* Substitute the switch(es) indicated by the current atom.  */
5710           ordered_set = true;
5711           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5712               || a_is_spectype || atom == end_atom)
5713             goto invalid;
5714
5715           mark_matching_switches (atom, end_atom, a_is_starred);
5716
5717           if (*p == '}')
5718             process_marked_switches ();
5719           break;
5720
5721         case '|': case ':':
5722           /* Substitute some text if the current atom appears as a switch
5723              or suffix.  */
5724           disjunct_set = true;
5725           if (ordered_set)
5726             goto invalid;
5727
5728           if (atom == end_atom)
5729             {
5730               if (!n_way_choice || disj_matched || *p == '|'
5731                   || a_is_negated || a_is_suffix || a_is_spectype
5732                   || a_is_starred)
5733                 goto invalid;
5734
5735               /* An empty term may appear as the last choice of an
5736                  N-way choice set; it means "otherwise".  */
5737               a_must_be_last = true;
5738               disj_matched = !n_way_matched;
5739               disj_starred = false;
5740             }
5741           else
5742             {
5743               if ((a_is_suffix || a_is_spectype) && a_is_starred)
5744                 goto invalid;
5745
5746               if (!a_is_starred)
5747                 disj_starred = false;
5748
5749               /* Don't bother testing this atom if we already have a
5750                  match.  */
5751               if (!disj_matched && !n_way_matched)
5752                 {
5753                   if (a_is_suffix)
5754                     a_matched = input_suffix_matches (atom, end_atom);
5755                   else if (a_is_spectype)
5756                     a_matched = input_spec_matches (atom, end_atom);
5757                   else
5758                     a_matched = switch_matches (atom, end_atom, a_is_starred);
5759
5760                   if (a_matched != a_is_negated)
5761                     {
5762                       disj_matched = true;
5763                       d_atom = atom;
5764                       d_end_atom = end_atom;
5765                     }
5766                 }
5767             }
5768
5769           if (*p == ':')
5770             {
5771               /* Found the body, that is, the text to substitute if the
5772                  current disjunction matches.  */
5773               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5774                                       disj_matched && !n_way_matched);
5775               if (p == 0)
5776                 return 0;
5777
5778               /* If we have an N-way choice, reset state for the next
5779                  disjunction.  */
5780               if (*p == ';')
5781                 {
5782                   n_way_choice = true;
5783                   n_way_matched |= disj_matched;
5784                   disj_matched = false;
5785                   disj_starred = true;
5786                   d_atom = d_end_atom = NULL;
5787                 }
5788             }
5789           break;
5790
5791         default:
5792           goto invalid;
5793         }
5794     }
5795   while (*p++ != '}');
5796
5797   return p;
5798
5799  invalid:
5800   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
5801
5802 #undef SKIP_WHITE
5803 }
5804
5805 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5806    (X in the description of %{} syntax).  P points one past the colon;
5807    ATOM and END_ATOM bracket the first atom which was found to be true
5808    (present) in the current disjunction; STARRED indicates whether all
5809    the atoms in the current disjunction were starred (for syntax validation);
5810    MATCHED indicates whether the disjunction matched or not, and therefore
5811    whether or not the body is to be processed through do_spec_1 or just
5812    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5813    returns -1.  */
5814
5815 static const char *
5816 process_brace_body (const char *p, const char *atom, const char *end_atom,
5817                     int starred, int matched)
5818 {
5819   const char *body, *end_body;
5820   unsigned int nesting_level;
5821   bool have_subst     = false;
5822
5823   /* Locate the closing } or ;, honoring nested braces.
5824      Trim trailing whitespace.  */
5825   body = p;
5826   nesting_level = 1;
5827   for (;;)
5828     {
5829       if (*p == '{')
5830         nesting_level++;
5831       else if (*p == '}')
5832         {
5833           if (!--nesting_level)
5834             break;
5835         }
5836       else if (*p == ';' && nesting_level == 1)
5837         break;
5838       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5839         have_subst = true;
5840       else if (*p == '\0')
5841         goto invalid;
5842       p++;
5843     }
5844
5845   end_body = p;
5846   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5847     end_body--;
5848
5849   if (have_subst && !starred)
5850     goto invalid;
5851
5852   if (matched)
5853     {
5854       /* Copy the substitution body to permanent storage and execute it.
5855          If have_subst is false, this is a simple matter of running the
5856          body through do_spec_1...  */
5857       char *string = save_string (body, end_body - body);
5858       if (!have_subst)
5859         {
5860           if (do_spec_1 (string, 0, NULL) < 0)
5861             return 0;
5862         }
5863       else
5864         {
5865           /* ... but if have_subst is true, we have to process the
5866              body once for each matching switch, with %* set to the
5867              variant part of the switch.  */
5868           unsigned int hard_match_len = end_atom - atom;
5869           int i;
5870
5871           for (i = 0; i < n_switches; i++)
5872             if (!strncmp (switches[i].part1, atom, hard_match_len)
5873                 && check_live_switch (i, hard_match_len))
5874               {
5875                 if (do_spec_1 (string, 0,
5876                                &switches[i].part1[hard_match_len]) < 0)
5877                   return 0;
5878                 /* Pass any arguments this switch has.  */
5879                 give_switch (i, 1);
5880                 suffix_subst = NULL;
5881               }
5882         }
5883     }
5884
5885   return p;
5886
5887  invalid:
5888   fatal ("braced spec body '%s' is invalid", body);
5889 }
5890 \f
5891 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5892    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5893    spec, or -1 if either exact match or %* is used.
5894
5895    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5896    whose value does not begin with "no-" is obsoleted by the same value
5897    with the "no-", similarly for a switch with the "no-" prefix.  */
5898
5899 static int
5900 check_live_switch (int switchnum, int prefix_length)
5901 {
5902   const char *name = switches[switchnum].part1;
5903   int i;
5904
5905   /* In the common case of {<at-most-one-letter>*}, a negating
5906      switch would always match, so ignore that case.  We will just
5907      send the conflicting switches to the compiler phase.  */
5908   if (prefix_length >= 0 && prefix_length <= 1)
5909     return 1;
5910
5911   /* If we already processed this switch and determined if it was
5912      live or not, return our past determination.  */
5913   if (switches[switchnum].live_cond != 0)
5914     return switches[switchnum].live_cond > 0;
5915
5916   /* Now search for duplicate in a manner that depends on the name.  */
5917   switch (*name)
5918     {
5919     case 'O':
5920       for (i = switchnum + 1; i < n_switches; i++)
5921         if (switches[i].part1[0] == 'O')
5922           {
5923             switches[switchnum].validated = 1;
5924             switches[switchnum].live_cond = SWITCH_FALSE;
5925             return 0;
5926           }
5927       break;
5928
5929     case 'W':  case 'f':  case 'm':
5930       if (! strncmp (name + 1, "no-", 3))
5931         {
5932           /* We have Xno-YYY, search for XYYY.  */
5933           for (i = switchnum + 1; i < n_switches; i++)
5934             if (switches[i].part1[0] == name[0]
5935                 && ! strcmp (&switches[i].part1[1], &name[4]))
5936               {
5937                 switches[switchnum].validated = 1;
5938                 switches[switchnum].live_cond = SWITCH_FALSE;
5939                 return 0;
5940               }
5941         }
5942       else
5943         {
5944           /* We have XYYY, search for Xno-YYY.  */
5945           for (i = switchnum + 1; i < n_switches; i++)
5946             if (switches[i].part1[0] == name[0]
5947                 && switches[i].part1[1] == 'n'
5948                 && switches[i].part1[2] == 'o'
5949                 && switches[i].part1[3] == '-'
5950                 && !strcmp (&switches[i].part1[4], &name[1]))
5951               {
5952                 switches[switchnum].validated = 1;
5953                 switches[switchnum].live_cond = SWITCH_FALSE;
5954                 return 0;
5955               }
5956         }
5957       break;
5958     }
5959
5960   /* Otherwise the switch is live.  */
5961   switches[switchnum].live_cond = SWITCH_LIVE;
5962   return 1;
5963 }
5964 \f
5965 /* Pass a switch to the current accumulating command
5966    in the same form that we received it.
5967    SWITCHNUM identifies the switch; it is an index into
5968    the vector of switches gcc received, which is `switches'.
5969    This cannot fail since it never finishes a command line.
5970
5971    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5972
5973 static void
5974 give_switch (int switchnum, int omit_first_word)
5975 {
5976   if (switches[switchnum].live_cond == SWITCH_IGNORE)
5977     return;
5978
5979   if (!omit_first_word)
5980     {
5981       do_spec_1 ("-", 0, NULL);
5982       do_spec_1 (switches[switchnum].part1, 1, NULL);
5983     }
5984
5985   if (switches[switchnum].args != 0)
5986     {
5987       const char **p;
5988       for (p = switches[switchnum].args; *p; p++)
5989         {
5990           const char *arg = *p;
5991
5992           do_spec_1 (" ", 0, NULL);
5993           if (suffix_subst)
5994             {
5995               unsigned length = strlen (arg);
5996               int dot = 0;
5997
5998               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5999                 if (arg[length] == '.')
6000                   {
6001                     (CONST_CAST(char *, arg))[length] = 0;
6002                     dot = 1;
6003                     break;
6004                   }
6005               do_spec_1 (arg, 1, NULL);
6006               if (dot)
6007                 (CONST_CAST(char *, arg))[length] = '.';
6008               do_spec_1 (suffix_subst, 1, NULL);
6009             }
6010           else
6011             do_spec_1 (arg, 1, NULL);
6012         }
6013     }
6014
6015   do_spec_1 (" ", 0, NULL);
6016   switches[switchnum].validated = 1;
6017 }
6018 \f
6019 /* Search for a file named NAME trying various prefixes including the
6020    user's -B prefix and some standard ones.
6021    Return the absolute file name found.  If nothing is found, return NAME.  */
6022
6023 static const char *
6024 find_file (const char *name)
6025 {
6026   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6027   return newname ? newname : name;
6028 }
6029
6030 /* Determine whether a directory exists.  If LINKER, return 0 for
6031    certain fixed names not needed by the linker.  */
6032
6033 static int
6034 is_directory (const char *path1, bool linker)
6035 {
6036   int len1;
6037   char *path;
6038   char *cp;
6039   struct stat st;
6040
6041   /* Ensure the string ends with "/.".  The resulting path will be a
6042      directory even if the given path is a symbolic link.  */
6043   len1 = strlen (path1);
6044   path = alloca (3 + len1);
6045   memcpy (path, path1, len1);
6046   cp = path + len1;
6047   if (!IS_DIR_SEPARATOR (cp[-1]))
6048     *cp++ = DIR_SEPARATOR;
6049   *cp++ = '.';
6050   *cp = '\0';
6051
6052   /* Exclude directories that the linker is known to search.  */
6053   if (linker
6054       && IS_DIR_SEPARATOR (path[0])
6055       && ((cp - path == 6
6056            && strncmp (path + 1, "lib", 3) == 0)
6057           || (cp - path == 10
6058               && strncmp (path + 1, "usr", 3) == 0
6059               && IS_DIR_SEPARATOR (path[4])
6060               && strncmp (path + 5, "lib", 3) == 0)))
6061     return 0;
6062
6063   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6064 }
6065
6066 /* Set up the various global variables to indicate that we're processing
6067    the input file named FILENAME.  */
6068
6069 void
6070 set_input (const char *filename)
6071 {
6072   const char *p;
6073
6074   input_filename = filename;
6075   input_filename_length = strlen (input_filename);
6076
6077   input_basename = input_filename;
6078 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
6079   /* Skip drive name so 'x:foo' is handled properly.  */
6080   if (input_basename[1] == ':')
6081     input_basename += 2;
6082 #endif
6083   for (p = input_basename; *p; p++)
6084     if (IS_DIR_SEPARATOR (*p))
6085       input_basename = p + 1;
6086
6087   /* Find a suffix starting with the last period,
6088      and set basename_length to exclude that suffix.  */
6089   basename_length = strlen (input_basename);
6090   suffixed_basename_length = basename_length;
6091   p = input_basename + basename_length;
6092   while (p != input_basename && *p != '.')
6093     --p;
6094   if (*p == '.' && p != input_basename)
6095     {
6096       basename_length = p - input_basename;
6097       input_suffix = p + 1;
6098     }
6099   else
6100     input_suffix = "";
6101
6102   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6103      we will need to do a stat on the input_filename.  The
6104      INPUT_STAT_SET signals that the stat is needed.  */
6105   input_stat_set = 0;
6106 }
6107 \f
6108 /* On fatal signals, delete all the temporary files.  */
6109
6110 static void
6111 fatal_error (int signum)
6112 {
6113   signal (signum, SIG_DFL);
6114   delete_failure_queue ();
6115   delete_temp_files ();
6116   /* Get the same signal again, this time not handled,
6117      so its normal effect occurs.  */
6118   kill (getpid (), signum);
6119 }
6120
6121 extern int main (int, char **);
6122
6123 int
6124 main (int argc, char **argv)
6125 {
6126   size_t i;
6127   int value;
6128   int linker_was_run = 0;
6129   int lang_n_infiles = 0;
6130   int num_linker_inputs = 0;
6131   char *explicit_link_files;
6132   char *specs_file;
6133   const char *p;
6134   struct user_specs *uptr;
6135   char **old_argv = argv;
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
7738   if (argc != 2)
7739     return NULL;
7740
7741   value = getenv (argv[0]);
7742   if (!value)
7743     fatal ("environment variable \"%s\" not defined", argv[0]);
7744
7745   return concat (value, argv[1], NULL);
7746 }
7747
7748 /* if-exists built-in spec function.
7749
7750    Checks to see if the file specified by the absolute pathname in
7751    ARGS exists.  Returns that pathname if found.
7752
7753    The usual use for this function is to check for a library file
7754    (whose name has been expanded with %s).  */
7755
7756 static const char *
7757 if_exists_spec_function (int argc, const char **argv)
7758 {
7759   /* Must have only one argument.  */
7760   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7761     return argv[0];
7762
7763   return NULL;
7764 }
7765
7766 /* if-exists-else built-in spec function.
7767
7768    This is like if-exists, but takes an additional argument which
7769    is returned if the first argument does not exist.  */
7770
7771 static const char *
7772 if_exists_else_spec_function (int argc, const char **argv)
7773 {
7774   /* Must have exactly two arguments.  */
7775   if (argc != 2)
7776     return NULL;
7777
7778   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7779     return argv[0];
7780
7781   return argv[1];
7782 }
7783
7784 /* replace-outfile built-in spec function.
7785
7786    This looks for the first argument in the outfiles array's name and
7787    replaces it with the second argument.  */
7788
7789 static const char *
7790 replace_outfile_spec_function (int argc, const char **argv)
7791 {
7792   int i;
7793   /* Must have exactly two arguments.  */
7794   if (argc != 2)
7795     abort ();
7796
7797   for (i = 0; i < n_infiles; i++)
7798     {
7799       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
7800         outfiles[i] = xstrdup (argv[1]);
7801     }
7802   return NULL;
7803 }
7804
7805 /* Given two version numbers, compares the two numbers.
7806    A version number must match the regular expression
7807    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7808 */
7809 static int
7810 compare_version_strings (const char *v1, const char *v2)
7811 {
7812   int rresult;
7813   regex_t r;
7814
7815   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7816                REG_EXTENDED | REG_NOSUB) != 0)
7817     abort ();
7818   rresult = regexec (&r, v1, 0, NULL, 0);
7819   if (rresult == REG_NOMATCH)
7820     fatal ("invalid version number `%s'", v1);
7821   else if (rresult != 0)
7822     abort ();
7823   rresult = regexec (&r, v2, 0, NULL, 0);
7824   if (rresult == REG_NOMATCH)
7825     fatal ("invalid version number `%s'", v2);
7826   else if (rresult != 0)
7827     abort ();
7828
7829   return strverscmp (v1, v2);
7830 }
7831
7832
7833 /* version_compare built-in spec function.
7834
7835    This takes an argument of the following form:
7836
7837    <comparison-op> <arg1> [<arg2>] <switch> <result>
7838
7839    and produces "result" if the comparison evaluates to true,
7840    and nothing if it doesn't.
7841
7842    The supported <comparison-op> values are:
7843
7844    >=  true if switch is a later (or same) version than arg1
7845    !>  opposite of >=
7846    <   true if switch is an earlier version than arg1
7847    !<  opposite of <
7848    ><  true if switch is arg1 or later, and earlier than arg2
7849    <>  true if switch is earlier than arg1 or is arg2 or later
7850
7851    If the switch is not present, the condition is false unless
7852    the first character of the <comparison-op> is '!'.
7853
7854    For example,
7855    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7856    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
7857
7858 static const char *
7859 version_compare_spec_function (int argc, const char **argv)
7860 {
7861   int comp1, comp2;
7862   size_t switch_len;
7863   const char *switch_value = NULL;
7864   int nargs = 1, i;
7865   bool result;
7866
7867   if (argc < 3)
7868     fatal ("too few arguments to %%:version-compare");
7869   if (argv[0][0] == '\0')
7870     abort ();
7871   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
7872     nargs = 2;
7873   if (argc != nargs + 3)
7874     fatal ("too many arguments to %%:version-compare");
7875
7876   switch_len = strlen (argv[nargs + 1]);
7877   for (i = 0; i < n_switches; i++)
7878     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
7879         && check_live_switch (i, switch_len))
7880       switch_value = switches[i].part1 + switch_len;
7881
7882   if (switch_value == NULL)
7883     comp1 = comp2 = -1;
7884   else
7885     {
7886       comp1 = compare_version_strings (switch_value, argv[1]);
7887       if (nargs == 2)
7888         comp2 = compare_version_strings (switch_value, argv[2]);
7889       else
7890         comp2 = -1;  /* This value unused.  */
7891     }
7892
7893   switch (argv[0][0] << 8 | argv[0][1])
7894     {
7895     case '>' << 8 | '=':
7896       result = comp1 >= 0;
7897       break;
7898     case '!' << 8 | '<':
7899       result = comp1 >= 0 || switch_value == NULL;
7900       break;
7901     case '<' << 8:
7902       result = comp1 < 0;
7903       break;
7904     case '!' << 8 | '>':
7905       result = comp1 < 0 || switch_value == NULL;
7906       break;
7907     case '>' << 8 | '<':
7908       result = comp1 >= 0 && comp2 < 0;
7909       break;
7910     case '<' << 8 | '>':
7911       result = comp1 < 0 || comp2 >= 0;
7912       break;
7913
7914     default:
7915       fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
7916     }
7917   if (! result)
7918     return NULL;
7919
7920   return argv[nargs + 2];
7921 }
7922
7923 /* %:include builtin spec function.  This differs from %include in that it
7924    can be nested inside a spec, and thus be conditionalized.  It takes
7925    one argument, the filename, and looks for it in the startfile path.
7926    The result is always NULL, i.e. an empty expansion.  */
7927
7928 static const char *
7929 include_spec_function (int argc, const char **argv)
7930 {
7931   char *file;
7932
7933   if (argc != 1)
7934     abort ();
7935
7936   file = find_a_file (&startfile_prefixes, argv[0], R_OK, 0);
7937   read_specs (file ? file : argv[0], FALSE);
7938
7939   return NULL;
7940 }
7941
7942 /* %:print-asm-header spec function.  Print a banner to say that the
7943    following output is from the assembler.  */
7944
7945 static const char *
7946 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
7947                                 const char **argv ATTRIBUTE_UNUSED)
7948 {
7949   printf (_("Assembler options\n=================\n\n"));
7950   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
7951   fflush (stdout);
7952   return NULL;
7953 }