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