gcc/gcc.c

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