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 and gfortranspec.c understands -static-libgfortran.  */
4562           if (!strcmp (p, "save-temps")
4563               || !strcmp (p, "static-libgcc")
4564               || !strcmp (p, "shared-libgcc")
4565               || !strcmp (p, "pipe")
4566               || !strcmp (p, "static-libgfortran"))
4567             switches[n_switches].validated = 1;
4568           else
4569             {
4570               char ch = switches[n_switches].part1[0];
4571               if (ch == 'B')
4572                 switches[n_switches].validated = 1;
4573             }
4574           n_switches++;
4575         }
4576       else
4577         {
4578           const char *p = strrchr (argv[i], '@');
4579           char *fname;
4580           long offset;
4581           int consumed;
4582 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4583           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4584 #endif
4585           /* For LTO static archive support we handle input file
4586              specifications that are composed of a filename and
4587              an offset like FNAME@OFFSET.  */
4588           if (p
4589               && p != argv[i]
4590               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4591               && strlen (p) == (unsigned int)consumed)
4592             {
4593               fname = (char *)xmalloc (p - argv[i] + 1);
4594               memcpy (fname, argv[i], p - argv[i]);
4595               fname[p - argv[i]] = '\0';
4596               /* Only accept non-stdin and existing FNAME parts, otherwise
4597                  try with the full name.  */
4598               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4599                 {
4600                   free (fname);
4601                   fname = xstrdup (argv[i]);
4602                 }
4603             }
4604           else
4605             fname = xstrdup (argv[i]);
4606
4607           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4608             {
4609               perror_with_name (fname);
4610               error_count++;
4611             }
4612           else
4613             {
4614               infiles[n_infiles].language = spec_lang;
4615               infiles[n_infiles++].name = argv[i];
4616             }
4617
4618           free (fname);
4619         }
4620     }
4621
4622   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4623     error ("warning: '-x %s' after last input file has no effect", spec_lang);
4624
4625   if (compare_debug == 2 || compare_debug == 3)
4626     {
4627       switches[n_switches].part1 = concat ("fcompare-debug=",
4628                                            compare_debug_opt,
4629                                            NULL);
4630       switches[n_switches].args = 0;
4631       switches[n_switches].live_cond = 0;
4632       switches[n_switches].validated = 0;
4633       switches[n_switches].ordering = 0;
4634       n_switches++;
4635       compare_debug = 1;
4636     }
4637
4638   /* Ensure we only invoke each subprocess once.  */
4639   if (print_subprocess_help || print_help_list || print_version)
4640     {
4641       n_infiles = 1;
4642
4643       /* Create a dummy input file, so that we can pass
4644          the help option on to the various sub-processes.  */
4645       infiles[0].language = "c";
4646       infiles[0].name   = "help-dummy";
4647     }
4648
4649   switches[n_switches].part1 = 0;
4650   infiles[n_infiles].name = 0;
4651 }
4652
4653 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4654    and place that in the environment.  */
4655
4656 static void
4657 set_collect_gcc_options (void)
4658 {
4659   int i;
4660   int first_time;
4661
4662   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4663      the compiler.  */
4664   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4665                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4666
4667   first_time = TRUE;
4668   for (i = 0; (int) i < n_switches; i++)
4669     {
4670       const char *const *args;
4671       const char *p, *q;
4672       if (!first_time)
4673         obstack_grow (&collect_obstack, " ", 1);
4674
4675       first_time = FALSE;
4676
4677       /* Ignore elided switches.  */
4678       if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4679         continue;
4680
4681       obstack_grow (&collect_obstack, "'-", 2);
4682       q = switches[i].part1;
4683       while ((p = strchr (q, '\'')))
4684         {
4685           obstack_grow (&collect_obstack, q, p - q);
4686           obstack_grow (&collect_obstack, "'\\''", 4);
4687           q = ++p;
4688         }
4689       obstack_grow (&collect_obstack, q, strlen (q));
4690       obstack_grow (&collect_obstack, "'", 1);
4691
4692       for (args = switches[i].args; args && *args; args++)
4693         {
4694           obstack_grow (&collect_obstack, " '", 2);
4695           q = *args;
4696           while ((p = strchr (q, '\'')))
4697             {
4698               obstack_grow (&collect_obstack, q, p - q);
4699               obstack_grow (&collect_obstack, "'\\''", 4);
4700               q = ++p;
4701             }
4702           obstack_grow (&collect_obstack, q, strlen (q));
4703           obstack_grow (&collect_obstack, "'", 1);
4704         }
4705     }
4706   obstack_grow (&collect_obstack, "\0", 1);
4707   xputenv (XOBFINISH (&collect_obstack, char *));
4708 }
4709 \f
4710 /* Process a spec string, accumulating and running commands.  */
4711
4712 /* These variables describe the input file name.
4713    input_file_number is the index on outfiles of this file,
4714    so that the output file name can be stored for later use by %o.
4715    input_basename is the start of the part of the input file
4716    sans all directory names, and basename_length is the number
4717    of characters starting there excluding the suffix .c or whatever.  */
4718
4719 static const char *input_filename;
4720 static int input_file_number;
4721 size_t input_filename_length;
4722 static int basename_length;
4723 static int suffixed_basename_length;
4724 static const char *input_basename;
4725 static const char *input_suffix;
4726 #ifndef HOST_LACKS_INODE_NUMBERS
4727 static struct stat input_stat;
4728 #endif
4729 static int input_stat_set;
4730
4731 /* The compiler used to process the current input file.  */
4732 static struct compiler *input_file_compiler;
4733
4734 /* These are variables used within do_spec and do_spec_1.  */
4735
4736 /* Nonzero if an arg has been started and not yet terminated
4737    (with space, tab or newline).  */
4738 static int arg_going;
4739
4740 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4741    is a temporary file name.  */
4742 static int delete_this_arg;
4743
4744 /* Nonzero means %w has been seen; the next arg to be terminated
4745    is the output file name of this compilation.  */
4746 static int this_is_output_file;
4747
4748 /* Nonzero means %s has been seen; the next arg to be terminated
4749    is the name of a library file and we should try the standard
4750    search dirs for it.  */
4751 static int this_is_library_file;
4752
4753 /* Nonzero means %T has been seen; the next arg to be terminated
4754    is the name of a linker script and we should try all of the
4755    standard search dirs for it.  If it is found insert a --script
4756    command line switch and then substitute the full path in place,
4757    otherwise generate an error message.  */
4758 static int this_is_linker_script;
4759
4760 /* Nonzero means that the input of this command is coming from a pipe.  */
4761 static int input_from_pipe;
4762
4763 /* Nonnull means substitute this for any suffix when outputting a switches
4764    arguments.  */
4765 static const char *suffix_subst;
4766
4767 /* If there is an argument being accumulated, terminate it and store it.  */
4768
4769 static void
4770 end_going_arg (void)
4771 {
4772   if (arg_going)
4773     {
4774       const char *string;
4775
4776       obstack_1grow (&obstack, 0);
4777       string = XOBFINISH (&obstack, const char *);
4778       if (this_is_library_file)
4779         string = find_file (string);
4780       if (this_is_linker_script)
4781         {
4782           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4783
4784           if (full_script_path == NULL)
4785             {
4786               error (_("unable to locate default linker script '%s' in the library search paths"), string);
4787               /* Script was not found on search path.  */
4788               return;
4789             }
4790           store_arg ("--script", false, false);
4791           string = full_script_path;
4792         }
4793       store_arg (string, delete_this_arg, this_is_output_file);
4794       if (this_is_output_file)
4795         outfiles[input_file_number] = string;
4796       arg_going = 0;
4797     }
4798 }
4799
4800
4801 /* Parse the WRAPPER string which is a comma separated list of the command line
4802    and insert them into the beginning of argbuf.  */
4803
4804 static void
4805 insert_wrapper (const char *wrapper)
4806 {
4807   int n = 0;
4808   int i;
4809   char *buf = xstrdup (wrapper);
4810   char *p = buf;
4811
4812   do
4813     {
4814       n++;
4815       while (*p == ',')
4816         p++;
4817     }
4818   while ((p = strchr (p, ',')) != NULL);
4819
4820   if (argbuf_index + n >= argbuf_length)
4821     {
4822       argbuf_length = argbuf_length * 2;
4823       while (argbuf_length < argbuf_index + n)
4824         argbuf_length *= 2;
4825       argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4826     }
4827   for (i = argbuf_index - 1; i >= 0; i--)
4828     argbuf[i + n] = argbuf[i];
4829
4830   i = 0;
4831   p = buf;
4832   do
4833     {
4834       while (*p == ',')
4835         {
4836           *p = 0;
4837           p++;
4838         }
4839       argbuf[i++] = p;
4840     }
4841   while ((p = strchr (p, ',')) != NULL);
4842   gcc_assert (i == n);
4843   argbuf_index += n;
4844 }
4845
4846 /* Process the spec SPEC and run the commands specified therein.
4847    Returns 0 if the spec is successfully processed; -1 if failed.  */
4848
4849 int
4850 do_spec (const char *spec)
4851 {
4852   int value;
4853
4854   value = do_spec_2 (spec);
4855
4856   /* Force out any unfinished command.
4857      If -pipe, this forces out the last command if it ended in `|'.  */
4858   if (value == 0)
4859     {
4860       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4861         argbuf_index--;
4862
4863       set_collect_gcc_options ();
4864
4865       if (argbuf_index > 0)
4866         value = execute ();
4867     }
4868
4869   return value;
4870 }
4871
4872 static int
4873 do_spec_2 (const char *spec)
4874 {
4875   int result;
4876
4877   clear_args ();
4878   arg_going = 0;
4879   delete_this_arg = 0;
4880   this_is_output_file = 0;
4881   this_is_library_file = 0;
4882   this_is_linker_script = 0;
4883   input_from_pipe = 0;
4884   suffix_subst = NULL;
4885
4886   result = do_spec_1 (spec, 0, NULL);
4887
4888   end_going_arg ();
4889
4890   return result;
4891 }
4892
4893
4894 /* Process the given spec string and add any new options to the end
4895    of the switches/n_switches array.  */
4896
4897 static void
4898 do_option_spec (const char *name, const char *spec)
4899 {
4900   unsigned int i, value_count, value_len;
4901   const char *p, *q, *value;
4902   char *tmp_spec, *tmp_spec_p;
4903
4904   if (configure_default_options[0].name == NULL)
4905     return;
4906
4907   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4908     if (strcmp (configure_default_options[i].name, name) == 0)
4909       break;
4910   if (i == ARRAY_SIZE (configure_default_options))
4911     return;
4912
4913   value = configure_default_options[i].value;
4914   value_len = strlen (value);
4915
4916   /* Compute the size of the final spec.  */
4917   value_count = 0;
4918   p = spec;
4919   while ((p = strstr (p, "%(VALUE)")) != NULL)
4920     {
4921       p ++;
4922       value_count ++;
4923     }
4924
4925   /* Replace each %(VALUE) by the specified value.  */
4926   tmp_spec = (char *) alloca (strlen (spec) + 1
4927                      + value_count * (value_len - strlen ("%(VALUE)")));
4928   tmp_spec_p = tmp_spec;
4929   q = spec;
4930   while ((p = strstr (q, "%(VALUE)")) != NULL)
4931     {
4932       memcpy (tmp_spec_p, q, p - q);
4933       tmp_spec_p = tmp_spec_p + (p - q);
4934       memcpy (tmp_spec_p, value, value_len);
4935       tmp_spec_p += value_len;
4936       q = p + strlen ("%(VALUE)");
4937     }
4938   strcpy (tmp_spec_p, q);
4939
4940   do_self_spec (tmp_spec);
4941 }
4942
4943 /* Process the given spec string and add any new options to the end
4944    of the switches/n_switches array.  */
4945
4946 static void
4947 do_self_spec (const char *spec)
4948 {
4949   int i;
4950
4951   do_spec_2 (spec);
4952   do_spec_1 (" ", 0, NULL);
4953
4954   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4955      do_self_specs adds the replacements to switches array, so it shouldn't
4956      be processed afterwards.  */
4957   for (i = 0; i < n_switches; i++)
4958     if ((switches[i].live_cond & SWITCH_IGNORE))
4959       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4960
4961   if (argbuf_index > 0)
4962     {
4963       switches = XRESIZEVEC (struct switchstr, switches,
4964                              n_switches + argbuf_index + 1);
4965
4966       for (i = 0; i < argbuf_index; i++)
4967         {
4968           struct switchstr *sw;
4969           const char *p = argbuf[i];
4970           int c = *p;
4971
4972           /* Each switch should start with '-'.  */
4973           if (c != '-')
4974             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4975
4976           p++;
4977           c = *p;
4978
4979           sw = &switches[n_switches++];
4980           sw->part1 = p;
4981           sw->live_cond = 0;
4982           sw->validated = 0;
4983           sw->ordering = 0;
4984
4985           /* Deal with option arguments in separate argv elements.  */
4986           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4987               || WORD_SWITCH_TAKES_ARG (p))
4988             {
4989               int j = 0;
4990               int n_args = WORD_SWITCH_TAKES_ARG (p);
4991
4992               if (n_args == 0)
4993                 {
4994                   /* Count only the option arguments in separate argv elements.  */
4995                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4996                 }
4997               if (i + n_args >= argbuf_index)
4998                 fatal ("argument to '-%s' is missing", p);
4999               sw->args
5000                 = XNEWVEC (const char *, n_args + 1);
5001               while (j < n_args)
5002                 sw->args[j++] = argbuf[++i];
5003               /* Null-terminate the vector.  */
5004               sw->args[j] = 0;
5005             }
5006           else if (strchr (switches_need_spaces, c))
5007             {
5008               /* On some systems, ld cannot handle some options without
5009                  a space.  So split the option from its argument.  */
5010               char *part1 = XNEWVEC (char, 2);
5011               part1[0] = c;
5012               part1[1] = '\0';
5013
5014               sw->part1 = part1;
5015               sw->args = XNEWVEC (const char *, 2);
5016               sw->args[0] = xstrdup (p+1);
5017               sw->args[1] = 0;
5018             }
5019           else
5020             sw->args = 0;
5021         }
5022
5023       switches[n_switches].part1 = 0;
5024     }
5025 }
5026
5027 /* Callback for processing %D and %I specs.  */
5028
5029 struct spec_path_info {
5030   const char *option;
5031   const char *append;
5032   size_t append_len;
5033   bool omit_relative;
5034   bool separate_options;
5035 };
5036
5037 static void *
5038 spec_path (char *path, void *data)
5039 {
5040   struct spec_path_info *info = (struct spec_path_info *) data;
5041   size_t len = 0;
5042   char save = 0;
5043
5044   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5045     return NULL;
5046
5047   if (info->append_len != 0)
5048     {
5049       len = strlen (path);
5050       memcpy (path + len, info->append, info->append_len + 1);
5051     }
5052
5053   if (!is_directory (path, true))
5054     return NULL;
5055
5056   do_spec_1 (info->option, 1, NULL);
5057   if (info->separate_options)
5058     do_spec_1 (" ", 0, NULL);
5059
5060   if (info->append_len == 0)
5061     {
5062       len = strlen (path);
5063       save = path[len - 1];
5064       if (IS_DIR_SEPARATOR (path[len - 1]))
5065         path[len - 1] = '\0';
5066     }
5067
5068   do_spec_1 (path, 1, NULL);
5069   do_spec_1 (" ", 0, NULL);
5070
5071   /* Must not damage the original path.  */
5072   if (info->append_len == 0)
5073     path[len - 1] = save;
5074
5075   return NULL;
5076 }
5077
5078 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5079    argument list. */
5080
5081 static void
5082 create_at_file (char **argv)
5083 {
5084   char *temp_file = make_temp_file ("");
5085   char *at_argument = concat ("@", temp_file, NULL);
5086   FILE *f = fopen (temp_file, "w");
5087   int status;
5088
5089   if (f == NULL)
5090     fatal ("could not open temporary response file %s",
5091            temp_file);
5092
5093   status = writeargv (argv, f);
5094
5095   if (status)
5096     fatal ("could not write to temporary response file %s",
5097            temp_file);
5098
5099   status = fclose (f);
5100
5101   if (EOF == status)
5102     fatal ("could not close temporary response file %s",
5103            temp_file);
5104
5105   store_arg (at_argument, 0, 0);
5106
5107   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5108 }
5109
5110 /* True if we should compile INFILE. */
5111
5112 static bool
5113 compile_input_file_p (struct infile *infile)
5114 {
5115   if ((!infile->language) || (infile->language[0] != '*'))
5116     if (infile->incompiler == input_file_compiler)
5117       return true;
5118   return false;
5119 }
5120
5121 /* Process the sub-spec SPEC as a portion of a larger spec.
5122    This is like processing a whole spec except that we do
5123    not initialize at the beginning and we do not supply a
5124    newline by default at the end.
5125    INSWITCH nonzero means don't process %-sequences in SPEC;
5126    in this case, % is treated as an ordinary character.
5127    This is used while substituting switches.
5128    INSWITCH nonzero also causes SPC not to terminate an argument.
5129
5130    Value is zero unless a line was finished
5131    and the command on that line reported an error.  */
5132
5133 static int
5134 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5135 {
5136   const char *p = spec;
5137   int c;
5138   int i;
5139   int value;
5140
5141   while ((c = *p++))
5142     /* If substituting a switch, treat all chars like letters.
5143        Otherwise, NL, SPC, TAB and % are special.  */
5144     switch (inswitch ? 'a' : c)
5145       {
5146       case '\n':
5147         end_going_arg ();
5148
5149         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5150           {
5151             /* A `|' before the newline means use a pipe here,
5152                but only if -pipe was specified.
5153                Otherwise, execute now and don't pass the `|' as an arg.  */
5154             if (use_pipes)
5155               {
5156                 input_from_pipe = 1;
5157                 break;
5158               }
5159             else
5160               argbuf_index--;
5161           }
5162
5163         set_collect_gcc_options ();
5164
5165         if (argbuf_index > 0)
5166           {
5167             value = execute ();
5168             if (value)
5169               return value;
5170           }
5171         /* Reinitialize for a new command, and for a new argument.  */
5172         clear_args ();
5173         arg_going = 0;
5174         delete_this_arg = 0;
5175         this_is_output_file = 0;
5176         this_is_library_file = 0;
5177         this_is_linker_script = 0;
5178         input_from_pipe = 0;
5179         break;
5180
5181       case '|':
5182         end_going_arg ();
5183
5184         /* Use pipe */
5185         obstack_1grow (&obstack, c);
5186         arg_going = 1;
5187         break;
5188
5189       case '\t':
5190       case ' ':
5191         end_going_arg ();
5192
5193         /* Reinitialize for a new argument.  */
5194         delete_this_arg = 0;
5195         this_is_output_file = 0;
5196         this_is_library_file = 0;
5197         this_is_linker_script = 0;
5198         break;
5199
5200       case '%':
5201         switch (c = *p++)
5202           {
5203           case 0:
5204             fatal ("spec '%s' invalid", spec);
5205
5206           case 'b':
5207             if (save_temps_length)
5208               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5209             else
5210               obstack_grow (&obstack, input_basename, basename_length);
5211             if (compare_debug < 0)
5212               obstack_grow (&obstack, ".gk", 3);
5213             arg_going = 1;
5214             break;
5215
5216           case 'B':
5217             if (save_temps_length)
5218               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5219             else
5220               obstack_grow (&obstack, input_basename, suffixed_basename_length);
5221             if (compare_debug < 0)
5222               obstack_grow (&obstack, ".gk", 3);
5223             arg_going = 1;
5224             break;
5225
5226           case 'd':
5227             delete_this_arg = 2;
5228             break;
5229
5230           /* Dump out the directories specified with LIBRARY_PATH,
5231              followed by the absolute directories
5232              that we search for startfiles.  */
5233           case 'D':
5234             {
5235               struct spec_path_info info;
5236
5237               info.option = "-L";
5238               info.append_len = 0;
5239 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5240               /* Used on systems which record the specified -L dirs
5241                  and use them to search for dynamic linking.
5242                  Relative directories always come from -B,
5243                  and it is better not to use them for searching
5244                  at run time.  In particular, stage1 loses.  */
5245               info.omit_relative = true;
5246 #else
5247               info.omit_relative = false;
5248 #endif
5249               info.separate_options = false;
5250
5251               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5252             }
5253             break;
5254
5255           case 'e':
5256             /* %efoo means report an error with `foo' as error message
5257                and don't execute any more commands for this file.  */
5258             {
5259               const char *q = p;
5260               char *buf;
5261               while (*p != 0 && *p != '\n')
5262                 p++;
5263               buf = (char *) alloca (p - q + 1);
5264               strncpy (buf, q, p - q);
5265               buf[p - q] = 0;
5266               error ("%s", _(buf));
5267               return -1;
5268             }
5269             break;
5270           case 'n':
5271             /* %nfoo means report a notice with `foo' on stderr.  */
5272             {
5273               const char *q = p;
5274               char *buf;
5275               while (*p != 0 && *p != '\n')
5276                 p++;
5277               buf = (char *) alloca (p - q + 1);
5278               strncpy (buf, q, p - q);
5279               buf[p - q] = 0;
5280               notice ("%s\n", _(buf));
5281               if (*p)
5282                 p++;
5283             }
5284             break;
5285
5286           case 'j':
5287             {
5288               struct stat st;
5289
5290               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5291                  defined, and it is not a directory, and it is
5292                  writable, use it.  Otherwise, treat this like any
5293                  other temporary file.  */
5294
5295               if ((!save_temps_flag)
5296                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5297                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
5298                 {
5299                   obstack_grow (&obstack, HOST_BIT_BUCKET,
5300                                 strlen (HOST_BIT_BUCKET));
5301                   delete_this_arg = 0;
5302                   arg_going = 1;
5303                   break;
5304                 }
5305             }
5306             goto create_temp_file;
5307           case '|':
5308             if (use_pipes)
5309               {
5310                 obstack_1grow (&obstack, '-');
5311                 delete_this_arg = 0;
5312                 arg_going = 1;
5313
5314                 /* consume suffix */
5315                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5316                   p++;
5317                 if (p[0] == '%' && p[1] == 'O')
5318                   p += 2;
5319
5320                 break;
5321               }
5322             goto create_temp_file;
5323           case 'm':
5324             if (use_pipes)
5325               {
5326                 /* consume suffix */
5327                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5328                   p++;
5329                 if (p[0] == '%' && p[1] == 'O')
5330                   p += 2;
5331
5332                 break;
5333               }
5334             goto create_temp_file;
5335           case 'g':
5336           case 'u':
5337           case 'U':
5338           create_temp_file:
5339               {
5340                 struct temp_name *t;
5341                 int suffix_length;
5342                 const char *suffix = p;
5343                 char *saved_suffix = NULL;
5344
5345                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5346                   p++;
5347                 suffix_length = p - suffix;
5348                 if (p[0] == '%' && p[1] == 'O')
5349                   {
5350                     p += 2;
5351                     /* We don't support extra suffix characters after %O.  */
5352                     if (*p == '.' || ISALNUM ((unsigned char) *p))
5353                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5354                     if (suffix_length == 0)
5355                       suffix = TARGET_OBJECT_SUFFIX;
5356                     else
5357                       {
5358                         saved_suffix
5359                           = XNEWVEC (char, suffix_length
5360                                      + strlen (TARGET_OBJECT_SUFFIX));
5361                         strncpy (saved_suffix, suffix, suffix_length);
5362                         strcpy (saved_suffix + suffix_length,
5363                                 TARGET_OBJECT_SUFFIX);
5364                       }
5365                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5366                   }
5367
5368                 if (compare_debug < 0)
5369                   {
5370                     suffix = concat (".gk", suffix, NULL);
5371                     suffix_length += 3;
5372                   }
5373
5374                 /* If -save-temps=obj and -o were specified, use that for the
5375                    temp file.  */
5376                 if (save_temps_length)
5377                   {
5378                     char *tmp;
5379                     temp_filename_length
5380                       = save_temps_length + suffix_length + 1;
5381                     tmp = (char *) alloca (temp_filename_length);
5382                     memcpy (tmp, save_temps_prefix, save_temps_length);
5383                     memcpy (tmp + save_temps_length, suffix, suffix_length);
5384                     tmp[save_temps_length + suffix_length] = '\0';
5385                     temp_filename = save_string (tmp,
5386                                                  temp_filename_length + 1);
5387                     obstack_grow (&obstack, temp_filename,
5388                                   temp_filename_length);
5389                     arg_going = 1;
5390                     delete_this_arg = 0;
5391                     break;
5392                   }
5393
5394                 /* If the input_filename has the same suffix specified
5395                    for the %g, %u, or %U, and -save-temps is specified,
5396                    we could end up using that file as an intermediate
5397                    thus clobbering the user's source file (.e.g.,
5398                    gcc -save-temps foo.s would clobber foo.s with the
5399                    output of cpp0).  So check for this condition and
5400                    generate a temp file as the intermediate.  */
5401
5402                 if (save_temps_flag)
5403                   {
5404                     char *tmp;
5405                     temp_filename_length = basename_length + suffix_length + 1;
5406                     tmp = (char *) alloca (temp_filename_length);
5407                     memcpy (tmp, input_basename, basename_length);
5408                     memcpy (tmp + basename_length, suffix, suffix_length);
5409                     tmp[basename_length + suffix_length] = '\0';
5410                     temp_filename = tmp;
5411
5412                     if (strcmp (temp_filename, input_filename) != 0)
5413                       {
5414 #ifndef HOST_LACKS_INODE_NUMBERS
5415                         struct stat st_temp;
5416
5417                         /* Note, set_input() resets input_stat_set to 0.  */
5418                         if (input_stat_set == 0)
5419                           {
5420                             input_stat_set = stat (input_filename, &input_stat);
5421                             if (input_stat_set >= 0)
5422                               input_stat_set = 1;
5423                           }
5424
5425                         /* If we have the stat for the input_filename
5426                            and we can do the stat for the temp_filename
5427                            then the they could still refer to the same
5428                            file if st_dev/st_ino's are the same.  */
5429                         if (input_stat_set != 1
5430                             || stat (temp_filename, &st_temp) < 0
5431                             || input_stat.st_dev != st_temp.st_dev
5432                             || input_stat.st_ino != st_temp.st_ino)
5433 #else
5434                         /* Just compare canonical pathnames.  */
5435                         char* input_realname = lrealpath (input_filename);
5436                         char* temp_realname = lrealpath (temp_filename);
5437                         bool files_differ = strcmp (input_realname, temp_realname);
5438                         free (input_realname);
5439                         free (temp_realname);
5440                         if (files_differ)
5441 #endif
5442                           {
5443                             temp_filename = save_string (temp_filename,
5444                                                          temp_filename_length + 1);
5445                             obstack_grow (&obstack, temp_filename,
5446                                                     temp_filename_length);
5447                             arg_going = 1;
5448                             delete_this_arg = 0;
5449                             break;
5450                           }
5451                       }
5452                   }
5453
5454                 /* See if we already have an association of %g/%u/%U and
5455                    suffix.  */
5456                 for (t = temp_names; t; t = t->next)
5457                   if (t->length == suffix_length
5458                       && strncmp (t->suffix, suffix, suffix_length) == 0
5459                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5460                     break;
5461
5462                 /* Make a new association if needed.  %u and %j
5463                    require one.  */
5464                 if (t == 0 || c == 'u' || c == 'j')
5465                   {
5466                     if (t == 0)
5467                       {
5468                         t = XNEW (struct temp_name);
5469                         t->next = temp_names;
5470                         temp_names = t;
5471                       }
5472                     t->length = suffix_length;
5473                     if (saved_suffix)
5474                       {
5475                         t->suffix = saved_suffix;
5476                         saved_suffix = NULL;
5477                       }
5478                     else
5479                       t->suffix = save_string (suffix, suffix_length);
5480                     t->unique = (c == 'u' || c == 'U' || c == 'j');
5481                     temp_filename = make_temp_file (t->suffix);
5482                     temp_filename_length = strlen (temp_filename);
5483                     t->filename = temp_filename;
5484                     t->filename_length = temp_filename_length;
5485                   }
5486
5487                 if (saved_suffix)
5488                   free (saved_suffix);
5489
5490                 obstack_grow (&obstack, t->filename, t->filename_length);
5491                 delete_this_arg = 1;
5492               }
5493             arg_going = 1;
5494             break;
5495
5496           case 'i':
5497             if (combine_inputs)
5498               {
5499                 if (at_file_supplied)
5500                   {
5501                     /* We are going to expand `%i' to `@FILE', where FILE
5502                        is a newly-created temporary filename.  The filenames
5503                        that would usually be expanded in place of %o will be
5504                        written to the temporary file.  */
5505                     char **argv;
5506                     int n_files = 0;
5507                     int j;
5508
5509                     for (i = 0; i < n_infiles; i++)
5510                       if (compile_input_file_p (&infiles[i]))
5511                         n_files++;
5512
5513                     argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5514
5515                     /* Copy the strings over.  */
5516                     for (i = 0, j = 0; i < n_infiles; i++)
5517                       if (compile_input_file_p (&infiles[i]))
5518                         {
5519                           argv[j] = CONST_CAST (char *, infiles[i].name);
5520                           infiles[i].compiled = true;
5521                           j++;
5522                         }
5523                     argv[j] = NULL;
5524
5525                     create_at_file (argv);
5526                   }
5527                 else
5528                   for (i = 0; (int) i < n_infiles; i++)
5529                     if (compile_input_file_p (&infiles[i]))
5530                       {
5531                         store_arg (infiles[i].name, 0, 0);
5532                         infiles[i].compiled = true;
5533                       }
5534               }
5535             else
5536               {
5537                 obstack_grow (&obstack, input_filename, input_filename_length);
5538                 arg_going = 1;
5539               }
5540             break;
5541
5542           case 'I':
5543             {
5544               struct spec_path_info info;
5545
5546               if (multilib_dir)
5547                 {
5548                   do_spec_1 ("-imultilib", 1, NULL);
5549                   /* Make this a separate argument.  */
5550                   do_spec_1 (" ", 0, NULL);
5551                   do_spec_1 (multilib_dir, 1, NULL);
5552                   do_spec_1 (" ", 0, NULL);
5553                 }
5554
5555               if (gcc_exec_prefix)
5556                 {
5557                   do_spec_1 ("-iprefix", 1, NULL);
5558                   /* Make this a separate argument.  */
5559                   do_spec_1 (" ", 0, NULL);
5560                   do_spec_1 (gcc_exec_prefix, 1, NULL);
5561                   do_spec_1 (" ", 0, NULL);
5562                 }
5563
5564               if (target_system_root_changed ||
5565                   (target_system_root && target_sysroot_hdrs_suffix))
5566                 {
5567                   do_spec_1 ("-isysroot", 1, NULL);
5568                   /* Make this a separate argument.  */
5569                   do_spec_1 (" ", 0, NULL);
5570                   do_spec_1 (target_system_root, 1, NULL);
5571                   if (target_sysroot_hdrs_suffix)
5572                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5573                   do_spec_1 (" ", 0, NULL);
5574                 }
5575
5576               info.option = "-isystem";
5577               info.append = "include";
5578               info.append_len = strlen (info.append);
5579               info.omit_relative = false;
5580               info.separate_options = true;
5581
5582               for_each_path (&include_prefixes, false, info.append_len,
5583                              spec_path, &info);
5584
5585               info.append = "include-fixed";
5586               if (*sysroot_hdrs_suffix_spec)
5587                 info.append = concat (info.append, dir_separator_str,
5588                                       multilib_dir, NULL);
5589               info.append_len = strlen (info.append);
5590               for_each_path (&include_prefixes, false, info.append_len,
5591                              spec_path, &info);
5592             }
5593             break;
5594
5595           case 'o':
5596             {
5597               int max = n_infiles;
5598               max += lang_specific_extra_outfiles;
5599
5600               if (HAVE_GNU_LD && at_file_supplied)
5601                 {
5602                   /* We are going to expand `%o' to `@FILE', where FILE
5603                      is a newly-created temporary filename.  The filenames
5604                      that would usually be expanded in place of %o will be
5605                      written to the temporary file.  */
5606
5607                   char **argv;
5608                   int n_files, j;
5609
5610                   /* Convert OUTFILES into a form suitable for writeargv.  */
5611
5612                   /* Determine how many are non-NULL.  */
5613                   for (n_files = 0, i = 0; i < max; i++)
5614                     n_files += outfiles[i] != NULL;
5615
5616                   argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5617
5618                   /* Copy the strings over.  */
5619                   for (i = 0, j = 0; i < max; i++)
5620                     if (outfiles[i])
5621                       {
5622                         argv[j] = CONST_CAST (char *, outfiles[i]);
5623                         j++;
5624                       }
5625                   argv[j] = NULL;
5626
5627                   create_at_file (argv);
5628                 }
5629               else
5630                 for (i = 0; i < max; i++)
5631                   if (outfiles[i])
5632                     store_arg (outfiles[i], 0, 0);
5633               break;
5634             }
5635
5636           case 'O':
5637             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5638             arg_going = 1;
5639             break;
5640
5641           case 's':
5642             this_is_library_file = 1;
5643             break;
5644
5645           case 'T':
5646             this_is_linker_script = 1;
5647             break;
5648
5649           case 'V':
5650             outfiles[input_file_number] = NULL;
5651             break;
5652
5653           case 'w':
5654             this_is_output_file = 1;
5655             break;
5656
5657           case 'W':
5658             {
5659               int cur_index = argbuf_index;
5660               /* Handle the {...} following the %W.  */
5661               if (*p != '{')
5662                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5663               p = handle_braces (p + 1);
5664               if (p == 0)
5665                 return -1;
5666               end_going_arg ();
5667               /* If any args were output, mark the last one for deletion
5668                  on failure.  */
5669               if (argbuf_index != cur_index)
5670                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5671               break;
5672             }
5673
5674           /* %x{OPTION} records OPTION for %X to output.  */
5675           case 'x':
5676             {
5677               const char *p1 = p;
5678               char *string;
5679
5680               /* Skip past the option value and make a copy.  */
5681               if (*p != '{')
5682                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5683               while (*p++ != '}')
5684                 ;
5685               string = save_string (p1 + 1, p - p1 - 2);
5686
5687               /* See if we already recorded this option.  */
5688               for (i = 0; i < n_linker_options; i++)
5689                 if (! strcmp (string, linker_options[i]))
5690                   {
5691                     free (string);
5692                     return 0;
5693                   }
5694
5695               /* This option is new; add it.  */
5696               add_linker_option (string, strlen (string));
5697             }
5698             break;
5699
5700           /* Dump out the options accumulated previously using %x.  */
5701           case 'X':
5702             for (i = 0; i < n_linker_options; i++)
5703               {
5704                 do_spec_1 (linker_options[i], 1, NULL);
5705                 /* Make each accumulated option a separate argument.  */
5706                 do_spec_1 (" ", 0, NULL);
5707               }
5708             break;
5709
5710           /* Dump out the options accumulated previously using -Wa,.  */
5711           case 'Y':
5712             for (i = 0; i < n_assembler_options; i++)
5713               {
5714                 do_spec_1 (assembler_options[i], 1, NULL);
5715                 /* Make each accumulated option a separate argument.  */
5716                 do_spec_1 (" ", 0, NULL);
5717               }
5718             break;
5719
5720           /* Dump out the options accumulated previously using -Wp,.  */
5721           case 'Z':
5722             for (i = 0; i < n_preprocessor_options; i++)
5723               {
5724                 do_spec_1 (preprocessor_options[i], 1, NULL);
5725                 /* Make each accumulated option a separate argument.  */
5726                 do_spec_1 (" ", 0, NULL);
5727               }
5728             break;
5729
5730             /* Here are digits and numbers that just process
5731                a certain constant string as a spec.  */
5732
5733           case '1':
5734             value = do_spec_1 (cc1_spec, 0, NULL);
5735             if (value != 0)
5736               return value;
5737             break;
5738
5739           case '2':
5740             value = do_spec_1 (cc1plus_spec, 0, NULL);
5741             if (value != 0)
5742               return value;
5743             break;
5744
5745           case 'a':
5746             value = do_spec_1 (asm_spec, 0, NULL);
5747             if (value != 0)
5748               return value;
5749             break;
5750
5751           case 'A':
5752             value = do_spec_1 (asm_final_spec, 0, NULL);
5753             if (value != 0)
5754               return value;
5755             break;
5756
5757           case 'C':
5758             {
5759               const char *const spec
5760                 = (input_file_compiler->cpp_spec
5761                    ? input_file_compiler->cpp_spec
5762                    : cpp_spec);
5763               value = do_spec_1 (spec, 0, NULL);
5764               if (value != 0)
5765                 return value;
5766             }
5767             break;
5768
5769           case 'E':
5770             value = do_spec_1 (endfile_spec, 0, NULL);
5771             if (value != 0)
5772               return value;
5773             break;
5774
5775           case 'l':
5776             value = do_spec_1 (link_spec, 0, NULL);
5777             if (value != 0)
5778               return value;
5779             break;
5780
5781           case 'L':
5782             value = do_spec_1 (lib_spec, 0, NULL);
5783             if (value != 0)
5784               return value;
5785             break;
5786
5787           case 'G':
5788             value = do_spec_1 (libgcc_spec, 0, NULL);
5789             if (value != 0)
5790               return value;
5791             break;
5792
5793           case 'R':
5794             /* We assume there is a directory
5795                separator at the end of this string.  */
5796             if (target_system_root)
5797               {
5798                 obstack_grow (&obstack, target_system_root,
5799                               strlen (target_system_root));
5800                 if (target_sysroot_suffix)
5801                   obstack_grow (&obstack, target_sysroot_suffix,
5802                                 strlen (target_sysroot_suffix));
5803               }
5804             break;
5805
5806           case 'S':
5807             value = do_spec_1 (startfile_spec, 0, NULL);
5808             if (value != 0)
5809               return value;
5810             break;
5811
5812             /* Here we define characters other than letters and digits.  */
5813
5814           case '{':
5815             p = handle_braces (p);
5816             if (p == 0)
5817               return -1;
5818             break;
5819
5820           case ':':
5821             p = handle_spec_function (p);
5822             if (p == 0)
5823               return -1;
5824             break;
5825
5826           case '%':
5827             obstack_1grow (&obstack, '%');
5828             break;
5829
5830           case '.':
5831             {
5832               unsigned len = 0;
5833
5834               while (p[len] && p[len] != ' ' && p[len] != '%')
5835                 len++;
5836               suffix_subst = save_string (p - 1, len + 1);
5837               p += len;
5838             }
5839            break;
5840
5841            /* Henceforth ignore the option(s) matching the pattern
5842               after the %<.  */
5843           case '<':
5844             {
5845               unsigned len = 0;
5846               int have_wildcard = 0;
5847               int i;
5848
5849               while (p[len] && p[len] != ' ' && p[len] != '\t')
5850                 len++;
5851
5852               if (p[len-1] == '*')
5853                 have_wildcard = 1;
5854
5855               for (i = 0; i < n_switches; i++)
5856                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5857                     && (have_wildcard || switches[i].part1[len] == '\0'))
5858                   {
5859                     switches[i].live_cond |= SWITCH_IGNORE;
5860                     switches[i].validated = 1;
5861                   }
5862
5863               p += len;
5864             }
5865             break;
5866
5867           case '*':
5868             if (soft_matched_part)
5869               {
5870                 do_spec_1 (soft_matched_part, 1, NULL);
5871                 do_spec_1 (" ", 0, NULL);
5872               }
5873             else
5874               /* Catch the case where a spec string contains something like
5875                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5876                  hand side of the :.  */
5877               error ("spec failure: '%%*' has not been initialized by pattern match");
5878             break;
5879
5880             /* Process a string found as the value of a spec given by name.
5881                This feature allows individual machine descriptions
5882                to add and use their own specs.
5883                %[...] modifies -D options the way %P does;
5884                %(...) uses the spec unmodified.  */
5885           case '[':
5886             error ("warning: use of obsolete %%[ operator in specs");
5887           case '(':
5888             {
5889               const char *name = p;
5890               struct spec_list *sl;
5891               int len;
5892
5893               /* The string after the S/P is the name of a spec that is to be
5894                  processed.  */
5895               while (*p && *p != ')' && *p != ']')
5896                 p++;
5897
5898               /* See if it's in the list.  */
5899               for (len = p - name, sl = specs; sl; sl = sl->next)
5900                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5901                   {
5902                     name = *(sl->ptr_spec);
5903 #ifdef DEBUG_SPECS
5904                     notice ("Processing spec %c%s%c, which is '%s'\n",
5905                             c, sl->name, (c == '(') ? ')' : ']', name);
5906 #endif
5907                     break;
5908                   }
5909
5910               if (sl)
5911                 {
5912                   if (c == '(')
5913                     {
5914                       value = do_spec_1 (name, 0, NULL);
5915                       if (value != 0)
5916                         return value;
5917                     }
5918                   else
5919                     {
5920                       char *x = (char *) alloca (strlen (name) * 2 + 1);
5921                       char *buf = x;
5922                       const char *y = name;
5923                       int flag = 0;
5924
5925                       /* Copy all of NAME into BUF, but put __ after
5926                          every -D and at the end of each arg.  */
5927                       while (1)
5928                         {
5929                           if (! strncmp (y, "-D", 2))
5930                             {
5931                               *x++ = '-';
5932                               *x++ = 'D';
5933                               *x++ = '_';
5934                               *x++ = '_';
5935                               y += 2;
5936                               flag = 1;
5937                               continue;
5938                             }
5939                           else if (flag
5940                                    && (*y == ' ' || *y == '\t' || *y == '='
5941                                        || *y == '}' || *y == 0))
5942                             {
5943                               *x++ = '_';
5944                               *x++ = '_';
5945                               flag = 0;
5946                             }
5947                           if (*y == 0)
5948                             break;
5949                           else
5950                             *x++ = *y++;
5951                         }
5952                       *x = 0;
5953
5954                       value = do_spec_1 (buf, 0, NULL);
5955                       if (value != 0)
5956                         return value;
5957                     }
5958                 }
5959
5960               /* Discard the closing paren or bracket.  */
5961               if (*p)
5962                 p++;
5963             }
5964             break;
5965
5966           default:
5967             error ("spec failure: unrecognized spec option '%c'", c);
5968             break;
5969           }
5970         break;
5971
5972       case '\\':
5973         /* Backslash: treat next character as ordinary.  */
5974         c = *p++;
5975
5976         /* Fall through.  */
5977       default:
5978         /* Ordinary character: put it into the current argument.  */
5979         obstack_1grow (&obstack, c);
5980         arg_going = 1;
5981       }
5982
5983   /* End of string.  If we are processing a spec function, we need to
5984      end any pending argument.  */
5985   if (processing_spec_function)
5986     end_going_arg ();
5987
5988   return 0;
5989 }
5990
5991 /* Look up a spec function.  */
5992
5993 static const struct spec_function *
5994 lookup_spec_function (const char *name)
5995 {
5996   const struct spec_function *sf;
5997
5998   for (sf = static_spec_functions; sf->name != NULL; sf++)
5999     if (strcmp (sf->name, name) == 0)
6000       return sf;
6001
6002   return NULL;
6003 }
6004
6005 /* Evaluate a spec function.  */
6006
6007 static const char *
6008 eval_spec_function (const char *func, const char *args)
6009 {
6010   const struct spec_function *sf;
6011   const char *funcval;
6012
6013   /* Saved spec processing context.  */
6014   int save_argbuf_index;
6015   int save_argbuf_length;
6016   const char **save_argbuf;
6017
6018   int save_arg_going;
6019   int save_delete_this_arg;
6020   int save_this_is_output_file;
6021   int save_this_is_library_file;
6022   int save_input_from_pipe;
6023   int save_this_is_linker_script;
6024   const char *save_suffix_subst;
6025
6026
6027   sf = lookup_spec_function (func);
6028   if (sf == NULL)
6029     fatal ("unknown spec function '%s'", func);
6030
6031   /* Push the spec processing context.  */
6032   save_argbuf_index = argbuf_index;
6033   save_argbuf_length = argbuf_length;
6034   save_argbuf = argbuf;
6035
6036   save_arg_going = arg_going;
6037   save_delete_this_arg = delete_this_arg;
6038   save_this_is_output_file = this_is_output_file;
6039   save_this_is_library_file = this_is_library_file;
6040   save_this_is_linker_script = this_is_linker_script;
6041   save_input_from_pipe = input_from_pipe;
6042   save_suffix_subst = suffix_subst;
6043
6044   /* Create a new spec processing context, and build the function
6045      arguments.  */
6046
6047   alloc_args ();
6048   if (do_spec_2 (args) < 0)
6049     fatal ("error in args to spec function '%s'", func);
6050
6051   /* argbuf_index is an index for the next argument to be inserted, and
6052      so contains the count of the args already inserted.  */
6053
6054   funcval = (*sf->func) (argbuf_index, argbuf);
6055
6056   /* Pop the spec processing context.  */
6057   argbuf_index = save_argbuf_index;
6058   argbuf_length = save_argbuf_length;
6059   free (argbuf);
6060   argbuf = save_argbuf;
6061
6062   arg_going = save_arg_going;
6063   delete_this_arg = save_delete_this_arg;
6064   this_is_output_file = save_this_is_output_file;
6065   this_is_library_file = save_this_is_library_file;
6066   this_is_linker_script = save_this_is_linker_script;
6067   input_from_pipe = save_input_from_pipe;
6068   suffix_subst = save_suffix_subst;
6069
6070   return funcval;
6071 }
6072
6073 /* Handle a spec function call of the form:
6074
6075    %:function(args)
6076
6077    ARGS is processed as a spec in a separate context and split into an
6078    argument vector in the normal fashion.  The function returns a string
6079    containing a spec which we then process in the caller's context, or
6080    NULL if no processing is required.  */
6081
6082 static const char *
6083 handle_spec_function (const char *p)
6084 {
6085   char *func, *args;
6086   const char *endp, *funcval;
6087   int count;
6088
6089   processing_spec_function++;
6090
6091   /* Get the function name.  */
6092   for (endp = p; *endp != '\0'; endp++)
6093     {
6094       if (*endp == '(')         /* ) */
6095         break;
6096       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
6097       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6098         fatal ("malformed spec function name");
6099     }
6100   if (*endp != '(')             /* ) */
6101     fatal ("no arguments for spec function");
6102   func = save_string (p, endp - p);
6103   p = ++endp;
6104
6105   /* Get the arguments.  */
6106   for (count = 0; *endp != '\0'; endp++)
6107     {
6108       /* ( */
6109       if (*endp == ')')
6110         {
6111           if (count == 0)
6112             break;
6113           count--;
6114         }
6115       else if (*endp == '(')    /* ) */
6116         count++;
6117     }
6118   /* ( */
6119   if (*endp != ')')
6120     fatal ("malformed spec function arguments");
6121   args = save_string (p, endp - p);
6122   p = ++endp;
6123
6124   /* p now points to just past the end of the spec function expression.  */
6125
6126   funcval = eval_spec_function (func, args);
6127   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6128     p = NULL;
6129
6130   free (func);
6131   free (args);
6132
6133   processing_spec_function--;
6134
6135   return p;
6136 }
6137
6138 /* Inline subroutine of handle_braces.  Returns true if the current
6139    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
6140 static inline bool
6141 input_suffix_matches (const char *atom, const char *end_atom)
6142 {
6143   return (input_suffix
6144           && !strncmp (input_suffix, atom, end_atom - atom)
6145           && input_suffix[end_atom - atom] == '\0');
6146 }
6147
6148 /* Subroutine of handle_braces.  Returns true if the current
6149    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
6150 static bool
6151 input_spec_matches (const char *atom, const char *end_atom)
6152 {
6153   return (input_file_compiler
6154           && input_file_compiler->suffix
6155           && input_file_compiler->suffix[0] != '\0'
6156           && !strncmp (input_file_compiler->suffix + 1, atom,
6157                        end_atom - atom)
6158           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6159 }
6160
6161 /* Subroutine of handle_braces.  Returns true if a switch
6162    matching the atom bracketed by ATOM and END_ATOM appeared on the
6163    command line.  */
6164 static bool
6165 switch_matches (const char *atom, const char *end_atom, int starred)
6166 {
6167   int i;
6168   int len = end_atom - atom;
6169   int plen = starred ? len : -1;
6170
6171   for (i = 0; i < n_switches; i++)
6172     if (!strncmp (switches[i].part1, atom, len)
6173         && (starred || switches[i].part1[len] == '\0')
6174         && check_live_switch (i, plen))
6175       return true;
6176
6177   return false;
6178 }
6179
6180 /* Inline subroutine of handle_braces.  Mark all of the switches which
6181    match ATOM (extends to END_ATOM; STARRED indicates whether there
6182    was a star after the atom) for later processing.  */
6183 static inline void
6184 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6185 {
6186   int i;
6187   int len = end_atom - atom;
6188   int plen = starred ? len : -1;
6189
6190   for (i = 0; i < n_switches; i++)
6191     if (!strncmp (switches[i].part1, atom, len)
6192         && (starred || switches[i].part1[len] == '\0')
6193         && check_live_switch (i, plen))
6194       switches[i].ordering = 1;
6195 }
6196
6197 /* Inline subroutine of handle_braces.  Process all the currently
6198    marked switches through give_switch, and clear the marks.  */
6199 static inline void
6200 process_marked_switches (void)
6201 {
6202   int i;
6203
6204   for (i = 0; i < n_switches; i++)
6205     if (switches[i].ordering == 1)
6206       {
6207         switches[i].ordering = 0;
6208         give_switch (i, 0);
6209       }
6210 }
6211
6212 /* Handle a %{ ... } construct.  P points just inside the leading {.
6213    Returns a pointer one past the end of the brace block, or 0
6214    if we call do_spec_1 and that returns -1.  */
6215
6216 static const char *
6217 handle_braces (const char *p)
6218 {
6219   const char *atom, *end_atom;
6220   const char *d_atom = NULL, *d_end_atom = NULL;
6221   const char *orig = p;
6222
6223   bool a_is_suffix;
6224   bool a_is_spectype;
6225   bool a_is_starred;
6226   bool a_is_negated;
6227   bool a_matched;
6228
6229   bool a_must_be_last = false;
6230   bool ordered_set    = false;
6231   bool disjunct_set   = false;
6232   bool disj_matched   = false;
6233   bool disj_starred   = true;
6234   bool n_way_choice   = false;
6235   bool n_way_matched  = false;
6236
6237 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6238
6239   do
6240     {
6241       if (a_must_be_last)
6242         goto invalid;
6243
6244       /* Scan one "atom" (S in the description above of %{}, possibly
6245          with '!', '.', '@', ',', or '*' modifiers).  */
6246       a_matched = false;
6247       a_is_suffix = false;
6248       a_is_starred = false;
6249       a_is_negated = false;
6250       a_is_spectype = false;
6251
6252       SKIP_WHITE();
6253       if (*p == '!')
6254         p++, a_is_negated = true;
6255
6256       SKIP_WHITE();
6257       if (*p == '.')
6258         p++, a_is_suffix = true;
6259       else if (*p == ',')
6260         p++, a_is_spectype = true;
6261
6262       atom = p;
6263       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6264              || *p == ',' || *p == '.' || *p == '@')
6265         p++;
6266       end_atom = p;
6267
6268       if (*p == '*')
6269         p++, a_is_starred = 1;
6270
6271       SKIP_WHITE();
6272       switch (*p)
6273         {
6274         case '&': case '}':
6275           /* Substitute the switch(es) indicated by the current atom.  */
6276           ordered_set = true;
6277           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6278               || a_is_spectype || atom == end_atom)
6279             goto invalid;
6280
6281           mark_matching_switches (atom, end_atom, a_is_starred);
6282
6283           if (*p == '}')
6284             process_marked_switches ();
6285           break;
6286
6287         case '|': case ':':
6288           /* Substitute some text if the current atom appears as a switch
6289              or suffix.  */
6290           disjunct_set = true;
6291           if (ordered_set)
6292             goto invalid;
6293
6294           if (atom == end_atom)
6295             {
6296               if (!n_way_choice || disj_matched || *p == '|'
6297                   || a_is_negated || a_is_suffix || a_is_spectype
6298                   || a_is_starred)
6299                 goto invalid;
6300
6301               /* An empty term may appear as the last choice of an
6302                  N-way choice set; it means "otherwise".  */
6303               a_must_be_last = true;
6304               disj_matched = !n_way_matched;
6305               disj_starred = false;
6306             }
6307           else
6308             {
6309               if ((a_is_suffix || a_is_spectype) && a_is_starred)
6310                 goto invalid;
6311
6312               if (!a_is_starred)
6313                 disj_starred = false;
6314
6315               /* Don't bother testing this atom if we already have a
6316                  match.  */
6317               if (!disj_matched && !n_way_matched)
6318                 {
6319                   if (a_is_suffix)
6320                     a_matched = input_suffix_matches (atom, end_atom);
6321                   else if (a_is_spectype)
6322                     a_matched = input_spec_matches (atom, end_atom);
6323                   else
6324                     a_matched = switch_matches (atom, end_atom, a_is_starred);
6325
6326                   if (a_matched != a_is_negated)
6327                     {
6328                       disj_matched = true;
6329                       d_atom = atom;
6330                       d_end_atom = end_atom;
6331                     }
6332                 }
6333             }
6334
6335           if (*p == ':')
6336             {
6337               /* Found the body, that is, the text to substitute if the
6338                  current disjunction matches.  */
6339               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6340                                       disj_matched && !n_way_matched);
6341               if (p == 0)
6342                 return 0;
6343
6344               /* If we have an N-way choice, reset state for the next
6345                  disjunction.  */
6346               if (*p == ';')
6347                 {
6348                   n_way_choice = true;
6349                   n_way_matched |= disj_matched;
6350                   disj_matched = false;
6351                   disj_starred = true;
6352                   d_atom = d_end_atom = NULL;
6353                 }
6354             }
6355           break;
6356
6357         default:
6358           goto invalid;
6359         }
6360     }
6361   while (*p++ != '}');
6362
6363   return p;
6364
6365  invalid:
6366   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6367
6368 #undef SKIP_WHITE
6369 }
6370
6371 /* Subroutine of handle_braces.  Scan and process a brace substitution body
6372    (X in the description of %{} syntax).  P points one past the colon;
6373    ATOM and END_ATOM bracket the first atom which was found to be true
6374    (present) in the current disjunction; STARRED indicates whether all
6375    the atoms in the current disjunction were starred (for syntax validation);
6376    MATCHED indicates whether the disjunction matched or not, and therefore
6377    whether or not the body is to be processed through do_spec_1 or just
6378    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
6379    returns -1.  */
6380
6381 static const char *
6382 process_brace_body (const char *p, const char *atom, const char *end_atom,
6383                     int starred, int matched)
6384 {
6385   const char *body, *end_body;
6386   unsigned int nesting_level;
6387   bool have_subst     = false;
6388
6389   /* Locate the closing } or ;, honoring nested braces.
6390      Trim trailing whitespace.  */
6391   body = p;
6392   nesting_level = 1;
6393   for (;;)
6394     {
6395       if (*p == '{')
6396         nesting_level++;
6397       else if (*p == '}')
6398         {
6399           if (!--nesting_level)
6400             break;
6401         }
6402       else if (*p == ';' && nesting_level == 1)
6403         break;
6404       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6405         have_subst = true;
6406       else if (*p == '\0')
6407         goto invalid;
6408       p++;
6409     }
6410
6411   end_body = p;
6412   while (end_body[-1] == ' ' || end_body[-1] == '\t')
6413     end_body--;
6414
6415   if (have_subst && !starred)
6416     goto invalid;
6417
6418   if (matched)
6419     {
6420       /* Copy the substitution body to permanent storage and execute it.
6421          If have_subst is false, this is a simple matter of running the
6422          body through do_spec_1...  */
6423       char *string = save_string (body, end_body - body);
6424       if (!have_subst)
6425         {
6426           if (do_spec_1 (string, 0, NULL) < 0)
6427             return 0;
6428         }
6429       else
6430         {
6431           /* ... but if have_subst is true, we have to process the
6432              body once for each matching switch, with %* set to the
6433              variant part of the switch.  */
6434           unsigned int hard_match_len = end_atom - atom;
6435           int i;
6436
6437           for (i = 0; i < n_switches; i++)
6438             if (!strncmp (switches[i].part1, atom, hard_match_len)
6439                 && check_live_switch (i, hard_match_len))
6440               {
6441                 if (do_spec_1 (string, 0,
6442                                &switches[i].part1[hard_match_len]) < 0)
6443                   return 0;
6444                 /* Pass any arguments this switch has.  */
6445                 give_switch (i, 1);
6446                 suffix_subst = NULL;
6447               }
6448         }
6449     }
6450
6451   return p;
6452
6453  invalid:
6454   fatal ("braced spec body '%s' is invalid", body);
6455 }
6456 \f
6457 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6458    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
6459    spec, or -1 if either exact match or %* is used.
6460
6461    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
6462    whose value does not begin with "no-" is obsoleted by the same value
6463    with the "no-", similarly for a switch with the "no-" prefix.  */
6464
6465 static int
6466 check_live_switch (int switchnum, int prefix_length)
6467 {
6468   const char *name = switches[switchnum].part1;
6469   int i;
6470
6471   /* If we already processed this switch and determined if it was
6472      live or not, return our past determination.  */
6473   if (switches[switchnum].live_cond != 0)
6474     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6475             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6476             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6477                == 0);
6478
6479   /* In the common case of {<at-most-one-letter>*}, a negating
6480      switch would always match, so ignore that case.  We will just
6481      send the conflicting switches to the compiler phase.  */
6482   if (prefix_length >= 0 && prefix_length <= 1)
6483     return 1;
6484
6485   /* Now search for duplicate in a manner that depends on the name.  */
6486   switch (*name)
6487     {
6488     case 'O':
6489       for (i = switchnum + 1; i < n_switches; i++)
6490         if (switches[i].part1[0] == 'O')
6491           {
6492             switches[switchnum].validated = 1;
6493             switches[switchnum].live_cond = SWITCH_FALSE;
6494             return 0;
6495           }
6496       break;
6497
6498     case 'W':  case 'f':  case 'm':
6499       if (! strncmp (name + 1, "no-", 3))
6500         {
6501           /* We have Xno-YYY, search for XYYY.  */
6502           for (i = switchnum + 1; i < n_switches; i++)
6503             if (switches[i].part1[0] == name[0]
6504                 && ! strcmp (&switches[i].part1[1], &name[4]))
6505               {
6506                 switches[switchnum].validated = 1;
6507                 switches[switchnum].live_cond = SWITCH_FALSE;
6508                 return 0;
6509               }
6510         }
6511       else
6512         {
6513           /* We have XYYY, search for Xno-YYY.  */
6514           for (i = switchnum + 1; i < n_switches; i++)
6515             if (switches[i].part1[0] == name[0]
6516                 && switches[i].part1[1] == 'n'
6517                 && switches[i].part1[2] == 'o'
6518                 && switches[i].part1[3] == '-'
6519                 && !strcmp (&switches[i].part1[4], &name[1]))
6520               {
6521                 switches[switchnum].validated = 1;
6522                 switches[switchnum].live_cond = SWITCH_FALSE;
6523                 return 0;
6524               }
6525         }
6526       break;
6527     }
6528
6529   /* Otherwise the switch is live.  */
6530   switches[switchnum].live_cond |= SWITCH_LIVE;
6531   return 1;
6532 }
6533 \f
6534 /* Pass a switch to the current accumulating command
6535    in the same form that we received it.
6536    SWITCHNUM identifies the switch; it is an index into
6537    the vector of switches gcc received, which is `switches'.
6538    This cannot fail since it never finishes a command line.
6539
6540    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
6541
6542 static void
6543 give_switch (int switchnum, int omit_first_word)
6544 {
6545   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6546     return;
6547
6548   if (!omit_first_word)
6549     {
6550       do_spec_1 ("-", 0, NULL);
6551       do_spec_1 (switches[switchnum].part1, 1, NULL);
6552     }
6553
6554   if (switches[switchnum].args != 0)
6555     {
6556       const char **p;
6557       for (p = switches[switchnum].args; *p; p++)
6558         {
6559           const char *arg = *p;
6560
6561           do_spec_1 (" ", 0, NULL);
6562           if (suffix_subst)
6563             {
6564               unsigned length = strlen (arg);
6565               int dot = 0;
6566
6567               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6568                 if (arg[length] == '.')
6569                   {
6570                     (CONST_CAST(char *, arg))[length] = 0;
6571                     dot = 1;
6572                     break;
6573                   }
6574               do_spec_1 (arg, 1, NULL);
6575               if (dot)
6576                 (CONST_CAST(char *, arg))[length] = '.';
6577               do_spec_1 (suffix_subst, 1, NULL);
6578             }
6579           else
6580             do_spec_1 (arg, 1, NULL);
6581         }
6582     }
6583
6584   do_spec_1 (" ", 0, NULL);
6585   switches[switchnum].validated = 1;
6586 }
6587 \f
6588 /* Search for a file named NAME trying various prefixes including the
6589    user's -B prefix and some standard ones.
6590    Return the absolute file name found.  If nothing is found, return NAME.  */
6591
6592 static const char *
6593 find_file (const char *name)
6594 {
6595   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6596   return newname ? newname : name;
6597 }
6598
6599 /* Determine whether a directory exists.  If LINKER, return 0 for
6600    certain fixed names not needed by the linker.  */
6601
6602 static int
6603 is_directory (const char *path1, bool linker)
6604 {
6605   int len1;
6606   char *path;
6607   char *cp;
6608   struct stat st;
6609
6610   /* Ensure the string ends with "/.".  The resulting path will be a
6611      directory even if the given path is a symbolic link.  */
6612   len1 = strlen (path1);
6613   path = (char *) alloca (3 + len1);
6614   memcpy (path, path1, len1);
6615   cp = path + len1;
6616   if (!IS_DIR_SEPARATOR (cp[-1]))
6617     *cp++ = DIR_SEPARATOR;
6618   *cp++ = '.';
6619   *cp = '\0';
6620
6621   /* Exclude directories that the linker is known to search.  */
6622   if (linker
6623       && IS_DIR_SEPARATOR (path[0])
6624       && ((cp - path == 6
6625            && strncmp (path + 1, "lib", 3) == 0)
6626           || (cp - path == 10
6627               && strncmp (path + 1, "usr", 3) == 0
6628               && IS_DIR_SEPARATOR (path[4])
6629               && strncmp (path + 5, "lib", 3) == 0)))
6630     return 0;
6631
6632   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6633 }
6634
6635 /* Set up the various global variables to indicate that we're processing
6636    the input file named FILENAME.  */
6637
6638 void
6639 set_input (const char *filename)
6640 {
6641   const char *p;
6642
6643   input_filename = filename;
6644   input_filename_length = strlen (input_filename);
6645   input_basename = lbasename (input_filename);
6646
6647   /* Find a suffix starting with the last period,
6648      and set basename_length to exclude that suffix.  */
6649   basename_length = strlen (input_basename);
6650   suffixed_basename_length = basename_length;
6651   p = input_basename + basename_length;
6652   while (p != input_basename && *p != '.')
6653     --p;
6654   if (*p == '.' && p != input_basename)
6655     {
6656       basename_length = p - input_basename;
6657       input_suffix = p + 1;
6658     }
6659   else
6660     input_suffix = "";
6661
6662   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6663      we will need to do a stat on the input_filename.  The
6664      INPUT_STAT_SET signals that the stat is needed.  */
6665   input_stat_set = 0;
6666 }
6667 \f
6668 /* On fatal signals, delete all the temporary files.  */
6669
6670 static void
6671 fatal_error (int signum)
6672 {
6673   signal (signum, SIG_DFL);
6674   delete_failure_queue ();
6675   delete_temp_files ();
6676   /* Get the same signal again, this time not handled,
6677      so its normal effect occurs.  */
6678   kill (getpid (), signum);
6679 }
6680
6681 /* Compare the contents of the two files named CMPFILE[0] and
6682    CMPFILE[1].  Return zero if they're identical, nonzero
6683    otherwise.  */
6684
6685 static int
6686 compare_files (char *cmpfile[])
6687 {
6688   int ret = 0;
6689   FILE *temp[2] = { NULL, NULL };
6690   int i;
6691
6692 #if HAVE_MMAP_FILE
6693   {
6694     size_t length[2];
6695     void *map[2] = { NULL, NULL };
6696
6697     for (i = 0; i < 2; i++)
6698       {
6699         struct stat st;
6700
6701         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6702           {
6703             error ("%s: could not determine length of compare-debug file %s",
6704                    input_filename, cmpfile[i]);
6705             ret = 1;
6706             break;
6707           }
6708
6709         length[i] = st.st_size;
6710       }
6711
6712     if (!ret && length[0] != length[1])
6713       {
6714         error ("%s: -fcompare-debug failure (length)", input_filename);
6715         ret = 1;
6716       }
6717
6718     if (!ret)
6719       for (i = 0; i < 2; i++)
6720         {
6721           int fd = open (cmpfile[i], O_RDONLY);
6722           if (fd < 0)
6723             {
6724               error ("%s: could not open compare-debug file %s",
6725                      input_filename, cmpfile[i]);
6726               ret = 1;
6727               break;
6728             }
6729
6730           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6731           close (fd);
6732
6733           if (map[i] == (void *) MAP_FAILED)
6734             {
6735               ret = -1;
6736               break;
6737             }
6738         }
6739
6740     if (!ret)
6741       {
6742         if (memcmp (map[0], map[1], length[0]) != 0)
6743           {
6744             error ("%s: -fcompare-debug failure", input_filename);
6745             ret = 1;
6746           }
6747       }
6748
6749     for (i = 0; i < 2; i++)
6750       if (map[i])
6751         munmap ((caddr_t) map[i], length[i]);
6752
6753     if (ret >= 0)
6754       return ret;
6755
6756     ret = 0;
6757   }
6758 #endif
6759
6760   for (i = 0; i < 2; i++)
6761     {
6762       temp[i] = fopen (cmpfile[i], "r");
6763       if (!temp[i])
6764         {
6765           error ("%s: could not open compare-debug file %s",
6766                  input_filename, cmpfile[i]);
6767           ret = 1;
6768           break;
6769         }
6770     }
6771
6772   if (!ret && temp[0] && temp[1])
6773     for (;;)
6774       {
6775         int c0, c1;
6776         c0 = fgetc (temp[0]);
6777         c1 = fgetc (temp[1]);
6778
6779         if (c0 != c1)
6780           {
6781             error ("%s: -fcompare-debug failure",
6782                    input_filename);
6783             ret = 1;
6784             break;
6785           }
6786
6787         if (c0 == EOF)
6788           break;
6789       }
6790
6791   for (i = 1; i >= 0; i--)
6792     {
6793       if (temp[i])
6794         fclose (temp[i]);
6795     }
6796
6797   return ret;
6798 }
6799
6800 extern int main (int, char **);
6801
6802 int
6803 main (int argc, char **argv)
6804 {
6805   size_t i;
6806   int value;
6807   int linker_was_run = 0;
6808   int lang_n_infiles = 0;
6809   int num_linker_inputs = 0;
6810   char *explicit_link_files;
6811   char *specs_file;
6812   const char *p;
6813   struct user_specs *uptr;
6814   char **old_argv = argv;
6815
6816   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
6817      on ?: in file-scope variable initializations.  */
6818   asm_debug = ASM_DEBUG_SPEC;
6819
6820   p = argv[0] + strlen (argv[0]);
6821   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6822     --p;
6823   programname = p;
6824
6825   xmalloc_set_program_name (programname);
6826
6827   expandargv (&argc, &argv);
6828
6829   /* Determine if any expansions were made.  */
6830   if (argv != old_argv)
6831     at_file_supplied = true;
6832
6833   prune_options (&argc, &argv);
6834
6835 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6836   /* Perform host dependent initialization when needed.  */
6837   GCC_DRIVER_HOST_INITIALIZATION;
6838 #endif
6839
6840   /* Unlock the stdio streams.  */
6841   unlock_std_streams ();
6842
6843   gcc_init_libintl ();
6844
6845   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6846     signal (SIGINT, fatal_error);
6847 #ifdef SIGHUP
6848   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6849     signal (SIGHUP, fatal_error);
6850 #endif
6851   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6852     signal (SIGTERM, fatal_error);
6853 #ifdef SIGPIPE
6854   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6855     signal (SIGPIPE, fatal_error);
6856 #endif
6857 #ifdef SIGCHLD
6858   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6859      receive the signal.  A different setting is inheritable */
6860   signal (SIGCHLD, SIG_DFL);
6861 #endif
6862
6863   /* Allocate the argument vector.  */
6864   alloc_args ();
6865
6866   obstack_init (&obstack);
6867
6868   /* Build multilib_select, et. al from the separate lines that make up each
6869      multilib selection.  */
6870   {
6871     const char *const *q = multilib_raw;
6872     int need_space;
6873
6874     obstack_init (&multilib_obstack);
6875     while ((p = *q++) != (char *) 0)
6876       obstack_grow (&multilib_obstack, p, strlen (p));
6877
6878     obstack_1grow (&multilib_obstack, 0);
6879     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6880
6881     q = multilib_matches_raw;
6882     while ((p = *q++) != (char *) 0)
6883       obstack_grow (&multilib_obstack, p, strlen (p));
6884
6885     obstack_1grow (&multilib_obstack, 0);
6886     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6887
6888     q = multilib_exclusions_raw;
6889     while ((p = *q++) != (char *) 0)
6890       obstack_grow (&multilib_obstack, p, strlen (p));
6891
6892     obstack_1grow (&multilib_obstack, 0);
6893     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6894
6895     need_space = FALSE;
6896     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6897       {
6898         if (need_space)
6899           obstack_1grow (&multilib_obstack, ' ');
6900         obstack_grow (&multilib_obstack,
6901                       multilib_defaults_raw[i],
6902                       strlen (multilib_defaults_raw[i]));
6903         need_space = TRUE;
6904       }
6905
6906     obstack_1grow (&multilib_obstack, 0);
6907     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6908   }
6909
6910 #ifdef INIT_ENVIRONMENT
6911   /* Set up any other necessary machine specific environment variables.  */
6912   xputenv (INIT_ENVIRONMENT);
6913 #endif
6914
6915   /* Make a table of what switches there are (switches, n_switches).
6916      Make a table of specified input files (infiles, n_infiles).
6917      Decode switches that are handled locally.  */
6918
6919   process_command (argc, CONST_CAST2 (const char **, char **, argv));
6920
6921   /* Initialize the vector of specs to just the default.
6922      This means one element containing 0s, as a terminator.  */
6923
6924   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6925   memcpy (compilers, default_compilers, sizeof default_compilers);
6926   n_compilers = n_default_compilers;
6927
6928   /* Read specs from a file if there is one.  */
6929
6930   machine_suffix = concat (spec_machine, dir_separator_str,
6931                            spec_version, dir_separator_str, NULL);
6932   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6933
6934   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6935   /* Read the specs file unless it is a default one.  */
6936   if (specs_file != 0 && strcmp (specs_file, "specs"))
6937     read_specs (specs_file, TRUE);
6938   else
6939     init_spec ();
6940
6941   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6942      for any override of as, ld and libraries.  */
6943   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6944                        + strlen (just_machine_suffix) + sizeof ("specs"));
6945
6946   strcpy (specs_file, standard_exec_prefix);
6947   strcat (specs_file, just_machine_suffix);
6948   strcat (specs_file, "specs");
6949   if (access (specs_file, R_OK) == 0)
6950     read_specs (specs_file, TRUE);
6951
6952   /* Process any configure-time defaults specified for the command line
6953      options, via OPTION_DEFAULT_SPECS.  */
6954   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6955     do_option_spec (option_default_specs[i].name,
6956                     option_default_specs[i].spec);
6957
6958   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6959      of the command line.  */
6960
6961   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6962     do_self_spec (driver_self_specs[i]);
6963
6964   if (compare_debug)
6965     {
6966       enum save_temps save;
6967
6968       if (!compare_debug_second)
6969         {
6970           n_switches_debug_check[1] = n_switches;
6971           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6972                                              n_switches + 1);
6973
6974           do_self_spec ("%:compare-debug-self-opt()");
6975           n_switches_debug_check[0] = n_switches;
6976           switches_debug_check[0] = switches;
6977
6978           n_switches = n_switches_debug_check[1];
6979           switches = switches_debug_check[1];
6980         }
6981
6982       /* Avoid crash when computing %j in this early.  */
6983       save = save_temps_flag;
6984       save_temps_flag = SAVE_TEMPS_NONE;
6985
6986       compare_debug = -compare_debug;
6987       do_self_spec ("%:compare-debug-self-opt()");
6988
6989       save_temps_flag = save;
6990
6991       if (!compare_debug_second)
6992         {
6993           n_switches_debug_check[1] = n_switches;
6994           switches_debug_check[1] = switches;
6995           compare_debug = -compare_debug;
6996           n_switches = n_switches_debug_check[0];
6997           switches = switches_debug_check[0];
6998         }
6999     }
7000
7001   /* If not cross-compiling, look for executables in the standard
7002      places.  */
7003   if (*cross_compile == '0')
7004     {
7005       if (*md_exec_prefix)
7006         {
7007           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
7008                       PREFIX_PRIORITY_LAST, 0, 0);
7009         }
7010     }
7011
7012   /* Process sysroot_suffix_spec.  */
7013   if (*sysroot_suffix_spec != 0
7014       && do_spec_2 (sysroot_suffix_spec) == 0)
7015     {
7016       if (argbuf_index > 1)
7017         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7018       else if (argbuf_index == 1)
7019         target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
7020     }
7021
7022 #ifdef HAVE_LD_SYSROOT
7023   /* Pass the --sysroot option to the linker, if it supports that.  If
7024      there is a sysroot_suffix_spec, it has already been processed by
7025      this point, so target_system_root really is the system root we
7026      should be using.  */
7027   if (target_system_root)
7028     {
7029       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7030       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
7031       set_spec ("link", XOBFINISH (&obstack, const char *));
7032     }
7033 #endif
7034
7035   /* Process sysroot_hdrs_suffix_spec.  */
7036   if (*sysroot_hdrs_suffix_spec != 0
7037       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
7038     {
7039       if (argbuf_index > 1)
7040         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7041       else if (argbuf_index == 1)
7042         target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
7043     }
7044
7045   /* Look for startfiles in the standard places.  */
7046   if (*startfile_prefix_spec != 0
7047       && do_spec_2 (startfile_prefix_spec) == 0
7048       && do_spec_1 (" ", 0, NULL) == 0)
7049     {
7050       int ndx;
7051       for (ndx = 0; ndx < argbuf_index; ndx++)
7052         add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
7053                               PREFIX_PRIORITY_LAST, 0, 1);
7054     }
7055   /* We should eventually get rid of all these and stick to
7056      startfile_prefix_spec exclusively.  */
7057   else if (*cross_compile == '0' || target_system_root)
7058     {
7059       if (*md_startfile_prefix)
7060         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
7061                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7062
7063       if (*md_startfile_prefix_1)
7064         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
7065                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7066
7067       /* If standard_startfile_prefix is relative, base it on
7068          standard_exec_prefix.  This lets us move the installed tree
7069          as a unit.  If GCC_EXEC_PREFIX is defined, base
7070          standard_startfile_prefix on that as well.
7071
7072          If the prefix is relative, only search it for native compilers;
7073          otherwise we will search a directory containing host libraries.  */
7074       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7075         add_sysrooted_prefix (&startfile_prefixes,
7076                               standard_startfile_prefix, "BINUTILS",
7077                               PREFIX_PRIORITY_LAST, 0, 1);
7078       else if (*cross_compile == '0')
7079         {
7080           add_prefix (&startfile_prefixes,
7081                       concat (gcc_exec_prefix
7082                               ? gcc_exec_prefix : standard_exec_prefix,
7083                               machine_suffix,
7084                               standard_startfile_prefix, NULL),
7085                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
7086         }
7087
7088       /* Sysrooted prefixes are relocated because target_system_root is
7089          also relocated by gcc_exec_prefix.  */
7090       if (*standard_startfile_prefix_1)
7091         add_sysrooted_prefix (&startfile_prefixes,
7092                               standard_startfile_prefix_1, "BINUTILS",
7093                               PREFIX_PRIORITY_LAST, 0, 1);
7094       if (*standard_startfile_prefix_2)
7095         add_sysrooted_prefix (&startfile_prefixes,
7096                               standard_startfile_prefix_2, "BINUTILS",
7097                               PREFIX_PRIORITY_LAST, 0, 1);
7098     }
7099
7100   /* Process any user specified specs in the order given on the command
7101      line.  */
7102   for (uptr = user_specs_head; uptr; uptr = uptr->next)
7103     {
7104       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7105                                     R_OK, true);
7106       read_specs (filename ? filename : uptr->filename, FALSE);
7107     }
7108
7109   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
7110   if (gcc_exec_prefix)
7111     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7112                               spec_version, dir_separator_str, NULL);
7113
7114   /* Now we have the specs.
7115      Set the `valid' bits for switches that match anything in any spec.  */
7116
7117   validate_all_switches ();
7118
7119   /* Now that we have the switches and the specs, set
7120      the subdirectory based on the options.  */
7121   set_multilib_dir ();
7122
7123   /* Set up to remember the pathname of gcc and any options
7124      needed for collect.  We use argv[0] instead of programname because
7125      we need the complete pathname.  */
7126   obstack_init (&collect_obstack);
7127   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7128   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7129   xputenv (XOBFINISH (&collect_obstack, char *));
7130
7131   /* Set up to remember the pathname of the lto wrapper. */
7132
7133   lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7134   if (lto_wrapper_spec)
7135     {
7136       obstack_init (&collect_obstack);
7137       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7138                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7139       obstack_grow (&collect_obstack, lto_wrapper_spec,
7140                     strlen (lto_wrapper_spec) + 1);
7141       xputenv (XOBFINISH (&collect_obstack, char *));
7142     }
7143
7144   /* Warn about any switches that no pass was interested in.  */
7145
7146   for (i = 0; (int) i < n_switches; i++)
7147     if (! switches[i].validated)
7148       error ("unrecognized option '-%s'", switches[i].part1);
7149
7150   /* Obey some of the options.  */
7151
7152   if (print_search_dirs)
7153     {
7154       printf (_("install: %s%s\n"),
7155               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7156               gcc_exec_prefix ? "" : machine_suffix);
7157       printf (_("programs: %s\n"),
7158               build_search_list (&exec_prefixes, "", false, false));
7159       printf (_("libraries: %s\n"),
7160               build_search_list (&startfile_prefixes, "", false, true));
7161       return (0);
7162     }
7163
7164   if (print_file_name)
7165     {
7166       printf ("%s\n", find_file (print_file_name));
7167       return (0);
7168     }
7169
7170   if (print_prog_name)
7171     {
7172       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7173       printf ("%s\n", (newname ? newname : print_prog_name));
7174       return (0);
7175     }
7176
7177   if (print_multi_lib)
7178     {
7179       print_multilib_info ();
7180       return (0);
7181     }
7182
7183   if (print_multi_directory)
7184     {
7185       if (multilib_dir == NULL)
7186         printf (".\n");
7187       else
7188         printf ("%s\n", multilib_dir);
7189       return (0);
7190     }
7191
7192   if (print_sysroot)
7193     {
7194       if (target_system_root)
7195         {
7196           if (target_sysroot_suffix)
7197             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7198           else
7199             printf ("%s\n", target_system_root);
7200         }
7201       return (0);
7202     }
7203
7204   if (print_multi_os_directory)
7205     {
7206       if (multilib_os_dir == NULL)
7207         printf (".\n");
7208       else
7209         printf ("%s\n", multilib_os_dir);
7210       return (0);
7211     }
7212
7213   if (print_sysroot_headers_suffix)
7214     {
7215       if (*sysroot_hdrs_suffix_spec)
7216         {
7217           printf("%s\n", (target_sysroot_hdrs_suffix
7218                           ? target_sysroot_hdrs_suffix
7219                           : ""));
7220           return (0);
7221         }
7222       else
7223         /* The error status indicates that only one set of fixed
7224            headers should be built.  */
7225         fatal ("not configured with sysroot headers suffix");
7226     }
7227
7228   if (print_help_list)
7229     {
7230       display_help ();
7231
7232       if (! verbose_flag)
7233         {
7234           printf (_("\nFor bug reporting instructions, please see:\n"));
7235           printf ("%s.\n", bug_report_url);
7236
7237           return (0);
7238         }
7239
7240       /* We do not exit here.  Instead we have created a fake input file
7241          called 'help-dummy' which needs to be compiled, and we pass this
7242          on the various sub-processes, along with the --help switch.
7243          Ensure their output appears after ours.  */
7244       fputc ('\n', stdout);
7245       fflush (stdout);
7246     }
7247
7248   if (print_version)
7249     {
7250       printf (_("%s %s%s\n"), programname, pkgversion_string,
7251               version_string);
7252       printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7253               _("(C)"));
7254       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
7255 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7256              stdout);
7257       if (! verbose_flag)
7258         return 0;
7259
7260       /* We do not exit here. We use the same mechanism of --help to print
7261          the version of the sub-processes. */
7262       fputc ('\n', stdout);
7263       fflush (stdout);
7264     }
7265
7266   if (verbose_flag)
7267     {
7268       int n;
7269       const char *thrmod;
7270
7271       notice ("Target: %s\n", spec_machine);
7272       notice ("Configured with: %s\n", configuration_arguments);
7273
7274 #ifdef THREAD_MODEL_SPEC
7275       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7276          but there's no point in doing all this processing just to get
7277          thread_model back.  */
7278       obstack_init (&obstack);
7279       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7280       obstack_1grow (&obstack, '\0');
7281       thrmod = XOBFINISH (&obstack, const char *);
7282 #else
7283       thrmod = thread_model;
7284 #endif
7285
7286       notice ("Thread model: %s\n", thrmod);
7287
7288       /* compiler_version is truncated at the first space when initialized
7289          from version string, so truncate version_string at the first space
7290          before comparing.  */
7291       for (n = 0; version_string[n]; n++)
7292         if (version_string[n] == ' ')
7293           break;
7294
7295       if (! strncmp (version_string, compiler_version, n)
7296           && compiler_version[n] == 0)
7297         notice ("gcc version %s %s\n", version_string, pkgversion_string);
7298       else
7299         notice ("gcc driver version %s %sexecuting gcc version %s\n",
7300                 version_string, pkgversion_string, compiler_version);
7301
7302       if (n_infiles == 0)
7303         return (0);
7304     }
7305
7306   if (n_infiles == added_libraries)
7307     fatal ("no input files");
7308
7309   /* Make a place to record the compiler output file names
7310      that correspond to the input files.  */
7311
7312   i = n_infiles;
7313   i += lang_specific_extra_outfiles;
7314   outfiles = XCNEWVEC (const char *, i);
7315
7316   /* Record which files were specified explicitly as link input.  */
7317
7318   explicit_link_files = XCNEWVEC (char, n_infiles);
7319
7320   if (combine_flag)
7321     combine_inputs = true;
7322   else
7323     combine_inputs = false;
7324
7325   for (i = 0; (int) i < n_infiles; i++)
7326     {
7327       const char *name = infiles[i].name;
7328       struct compiler *compiler = lookup_compiler (name,
7329                                                    strlen (name),
7330                                                    infiles[i].language);
7331
7332       if (compiler && !(compiler->combinable))
7333         combine_inputs = false;
7334
7335       if (lang_n_infiles > 0 && compiler != input_file_compiler
7336           && infiles[i].language && infiles[i].language[0] != '*')
7337         infiles[i].incompiler = compiler;
7338       else if (compiler)
7339         {
7340           lang_n_infiles++;
7341           input_file_compiler = compiler;
7342           infiles[i].incompiler = compiler;
7343         }
7344       else
7345         {
7346           /* Since there is no compiler for this input file, assume it is a
7347              linker file.  */
7348           explicit_link_files[i] = 1;
7349           infiles[i].incompiler = NULL;
7350         }
7351       infiles[i].compiled = false;
7352       infiles[i].preprocessed = false;
7353     }
7354
7355   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7356    fatal ("cannot specify -o with -c, -S or -E with multiple files");
7357
7358   if (combine_flag && save_temps_flag)
7359     {
7360       bool save_combine_inputs = combine_inputs;
7361       /* Must do a separate pre-processing pass for C & Objective-C files, to
7362          obtain individual .i files.  */
7363
7364       combine_inputs = false;
7365       for (i = 0; (int) i < n_infiles; i++)
7366         {
7367           int this_file_error = 0;
7368
7369           input_file_number = i;
7370           set_input (infiles[i].name);
7371           if (infiles[i].incompiler
7372               && (infiles[i].incompiler)->needs_preprocessing)
7373             input_file_compiler = infiles[i].incompiler;
7374           else
7375             continue;
7376
7377           if (input_file_compiler)
7378             {
7379               if (input_file_compiler->spec[0] == '#')
7380                 {
7381                   error ("%s: %s compiler not installed on this system",
7382                          input_filename, &input_file_compiler->spec[1]);
7383                   this_file_error = 1;
7384                 }
7385               else
7386                 {
7387                   value = do_spec (input_file_compiler->spec);
7388                   infiles[i].preprocessed = true;
7389                   if (!have_o_argbuf_index)
7390                     fatal ("spec '%s' is invalid", input_file_compiler->spec);
7391                   infiles[i].name = argbuf[have_o_argbuf_index];
7392                   infiles[i].incompiler
7393                     = lookup_compiler (infiles[i].name,
7394                                        strlen (infiles[i].name),
7395                                        infiles[i].language);
7396
7397                   if (value < 0)
7398                     this_file_error = 1;
7399                 }
7400             }
7401
7402           if (this_file_error)
7403             {
7404               delete_failure_queue ();
7405               error_count++;
7406               break;
7407             }
7408           clear_failure_queue ();
7409         }
7410       combine_inputs = save_combine_inputs;
7411     }
7412
7413   for (i = 0; (int) i < n_infiles; i++)
7414     {
7415       int this_file_error = 0;
7416
7417       /* Tell do_spec what to substitute for %i.  */
7418
7419       input_file_number = i;
7420       set_input (infiles[i].name);
7421
7422       if (infiles[i].compiled)
7423         continue;
7424
7425       /* Use the same thing in %o, unless cp->spec says otherwise.  */
7426
7427       outfiles[i] = input_filename;
7428
7429       /* Figure out which compiler from the file's suffix.  */
7430
7431       if (! combine_inputs)
7432         input_file_compiler
7433           = lookup_compiler (infiles[i].name, input_filename_length,
7434                              infiles[i].language);
7435       else
7436         input_file_compiler = infiles[i].incompiler;
7437
7438       if (input_file_compiler)
7439         {
7440           /* Ok, we found an applicable compiler.  Run its spec.  */
7441
7442           if (input_file_compiler->spec[0] == '#')
7443             {
7444               error ("%s: %s compiler not installed on this system",
7445                      input_filename, &input_file_compiler->spec[1]);
7446               this_file_error = 1;
7447             }
7448           else
7449             {
7450               if (compare_debug)
7451                 {
7452                   if (debug_check_temp_file[0])
7453                     free (debug_check_temp_file[0]);
7454                   debug_check_temp_file[0] = NULL;
7455
7456                   if (debug_check_temp_file[1])
7457                     free (debug_check_temp_file[1]);
7458                   debug_check_temp_file[1] = NULL;
7459                 }
7460
7461               value = do_spec (input_file_compiler->spec);
7462               infiles[i].compiled = true;
7463               if (value < 0)
7464                 this_file_error = 1;
7465               else if (compare_debug && debug_check_temp_file[0])
7466                 {
7467                   if (verbose_flag)
7468                     error ("Recompiling with -fcompare-debug");
7469
7470                   compare_debug = -compare_debug;
7471                   n_switches = n_switches_debug_check[1];
7472                   switches = switches_debug_check[1];
7473
7474                   value = do_spec (input_file_compiler->spec);
7475
7476                   compare_debug = -compare_debug;
7477                   n_switches = n_switches_debug_check[0];
7478                   switches = switches_debug_check[0];
7479
7480                   if (value < 0)
7481                     {
7482                       error ("during -fcompare-debug recompilation");
7483                       this_file_error = 1;
7484                     }
7485
7486                   gcc_assert (debug_check_temp_file[1]
7487                               && strcmp (debug_check_temp_file[0],
7488                                          debug_check_temp_file[1]));
7489
7490                   if (verbose_flag)
7491                     error ("Comparing final insns dumps");
7492
7493                   if (compare_files (debug_check_temp_file))
7494                     this_file_error = 1;
7495                 }
7496
7497               if (compare_debug)
7498                 {
7499                   if (debug_check_temp_file[0])
7500                     free (debug_check_temp_file[0]);
7501                   debug_check_temp_file[0] = NULL;
7502
7503                   if (debug_check_temp_file[1])
7504                     free (debug_check_temp_file[1]);
7505                   debug_check_temp_file[1] = NULL;
7506                 }
7507             }
7508         }
7509
7510       /* If this file's name does not contain a recognized suffix,
7511          record it as explicit linker input.  */
7512
7513       else
7514         explicit_link_files[i] = 1;
7515
7516       /* Clear the delete-on-failure queue, deleting the files in it
7517          if this compilation failed.  */
7518
7519       if (this_file_error)
7520         {
7521           delete_failure_queue ();
7522           error_count++;
7523         }
7524       /* If this compilation succeeded, don't delete those files later.  */
7525       clear_failure_queue ();
7526     }
7527
7528   /* Reset the input file name to the first compile/object file name, for use
7529      with %b in LINK_SPEC. We use the first input file that we can find
7530      a compiler to compile it instead of using infiles.language since for
7531      languages other than C we use aliases that we then lookup later.  */
7532   if (n_infiles > 0)
7533     {
7534       int i;
7535
7536       for (i = 0; i < n_infiles ; i++)
7537         if (infiles[i].language && infiles[i].language[0] != '*')
7538           {
7539             set_input (infiles[i].name);
7540             break;
7541           }
7542     }
7543
7544   if (error_count == 0)
7545     {
7546       /* Make sure INPUT_FILE_NUMBER points to first available open
7547          slot.  */
7548       input_file_number = n_infiles;
7549       if (lang_specific_pre_link ())
7550         error_count++;
7551     }
7552
7553   /* Determine if there are any linker input files.  */
7554   num_linker_inputs = 0;
7555   for (i = 0; (int) i < n_infiles; i++)
7556     if (explicit_link_files[i] || outfiles[i] != NULL)
7557       num_linker_inputs++;
7558
7559   /* Run ld to link all the compiler output files.  */
7560
7561   if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7562     {
7563       int tmp = execution_count;
7564       const char *fuse_linker_plugin = "fuse-linker-plugin";
7565
7566       /* We'll use ld if we can't find collect2.  */
7567       if (! strcmp (linker_name_spec, "collect2"))
7568         {
7569           char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7570           if (s == NULL)
7571             linker_name_spec = "ld";
7572         }
7573
7574       if (switch_matches (fuse_linker_plugin,
7575                           fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7576         {
7577           linker_plugin_file_spec = find_a_file (&exec_prefixes,
7578                                                  "liblto_plugin.so", X_OK,
7579                                                  false);
7580           if (!linker_plugin_file_spec)
7581             fatal ("-fuse-linker-plugin, but liblto_plugin.so not found");
7582
7583           lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7584                                          R_OK, true);
7585           if (!lto_libgcc_spec)
7586             fatal ("could not find libgcc.a");
7587         }
7588       lto_gcc_spec = argv[0];
7589
7590       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7591          for collect.  */
7592       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7593       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7594
7595       if (print_subprocess_help == 1)
7596         {
7597           printf (_("\nLinker options\n==============\n\n"));
7598           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7599                     " to the linker.\n\n"));
7600           fflush (stdout);
7601         }
7602       value = do_spec (link_command_spec);
7603       if (value < 0)
7604         error_count = 1;
7605       linker_was_run = (tmp != execution_count);
7606     }
7607
7608   /* If options said don't run linker,
7609      complain about input files to be given to the linker.  */
7610
7611   if (! linker_was_run && error_count == 0)
7612     for (i = 0; (int) i < n_infiles; i++)
7613       if (explicit_link_files[i]
7614           && !(infiles[i].language && infiles[i].language[0] == '*'))
7615         error ("%s: linker input file unused because linking not done",
7616                outfiles[i]);
7617
7618   /* Delete some or all of the temporary files we made.  */
7619
7620   if (error_count)
7621     delete_failure_queue ();
7622   delete_temp_files ();
7623
7624   if (print_help_list)
7625     {
7626       printf (("\nFor bug reporting instructions, please see:\n"));
7627       printf ("%s\n", bug_report_url);
7628     }
7629
7630   return (signal_count != 0 ? 2
7631           : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7632           : 0);
7633 }
7634
7635 /* Find the proper compilation spec for the file name NAME,
7636    whose length is LENGTH.  LANGUAGE is the specified language,
7637    or 0 if this file is to be passed to the linker.  */
7638
7639 static struct compiler *
7640 lookup_compiler (const char *name, size_t length, const char *language)
7641 {
7642   struct compiler *cp;
7643
7644   /* If this was specified by the user to be a linker input, indicate that.  */
7645   if (language != 0 && language[0] == '*')
7646     return 0;
7647
7648   /* Otherwise, look for the language, if one is spec'd.  */
7649   if (language != 0)
7650     {
7651       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7652         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7653           return cp;
7654
7655       error ("language %s not recognized", language);
7656       return 0;
7657     }
7658
7659   /* Look for a suffix.  */
7660   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7661     {
7662       if (/* The suffix `-' matches only the file name `-'.  */
7663           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7664           || (strlen (cp->suffix) < length
7665               /* See if the suffix matches the end of NAME.  */
7666               && !strcmp (cp->suffix,
7667                           name + length - strlen (cp->suffix))
7668          ))
7669         break;
7670     }
7671
7672 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7673   /* Look again, but case-insensitively this time.  */
7674   if (cp < compilers)
7675     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7676       {
7677         if (/* The suffix `-' matches only the file name `-'.  */
7678             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7679             || (strlen (cp->suffix) < length
7680                 /* See if the suffix matches the end of NAME.  */
7681                 && ((!strcmp (cp->suffix,
7682                              name + length - strlen (cp->suffix))
7683                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7684                     && !strcasecmp (cp->suffix,
7685                                     name + length - strlen (cp->suffix)))
7686            ))
7687           break;
7688       }
7689 #endif
7690
7691   if (cp >= compilers)
7692     {
7693       if (cp->spec[0] != '@')
7694         /* A non-alias entry: return it.  */
7695         return cp;
7696
7697       /* An alias entry maps a suffix to a language.
7698          Search for the language; pass 0 for NAME and LENGTH
7699          to avoid infinite recursion if language not found.  */
7700       return lookup_compiler (NULL, 0, cp->spec + 1);
7701     }
7702   return 0;
7703 }
7704 \f
7705 static char *
7706 save_string (const char *s, int len)
7707 {
7708   char *result = XNEWVEC (char, len + 1);
7709
7710   memcpy (result, s, len);
7711   result[len] = 0;
7712   return result;
7713 }
7714
7715 void
7716 pfatal_with_name (const char *name)
7717 {
7718   perror_with_name (name);
7719   delete_temp_files ();
7720   exit (1);
7721 }
7722
7723 static void
7724 perror_with_name (const char *name)
7725 {
7726   error ("%s: %s", name, xstrerror (errno));
7727 }
7728
7729 /* Output an error message and exit.  */
7730
7731 void
7732 fancy_abort (const char *file, int line, const char *func)
7733 {
7734   fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7735 }
7736 \f
7737 /* Output an error message and exit.  */
7738
7739 void
7740 fatal_ice (const char *cmsgid, ...)
7741 {
7742   va_list ap;
7743
7744   va_start (ap, cmsgid);
7745
7746   fprintf (stderr, "%s: ", programname);
7747   vfprintf (stderr, _(cmsgid), ap);
7748   va_end (ap);
7749   fprintf (stderr, "\n");
7750   delete_temp_files ();
7751   exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7752 }
7753
7754 void
7755 fatal (const char *cmsgid, ...)
7756 {
7757   va_list ap;
7758
7759   va_start (ap, cmsgid);
7760
7761   fprintf (stderr, "%s: ", programname);
7762   vfprintf (stderr, _(cmsgid), ap);
7763   va_end (ap);
7764   fprintf (stderr, "\n");
7765   delete_temp_files ();
7766   exit (1);
7767 }
7768
7769 /* The argument is actually c-format, not gcc-internal-format,
7770    but because functions with identical names are used through
7771    the rest of the compiler with gcc-internal-format, we just
7772    need to hope all users of these functions use the common
7773    subset between c-format and gcc-internal-format.  */
7774
7775 void
7776 error (const char *gmsgid, ...)
7777 {
7778   va_list ap;
7779
7780   va_start (ap, gmsgid);
7781   fprintf (stderr, "%s: ", programname);
7782   vfprintf (stderr, _(gmsgid), ap);
7783   va_end (ap);
7784
7785   fprintf (stderr, "\n");
7786 }
7787
7788 static void
7789 notice (const char *cmsgid, ...)
7790 {
7791   va_list ap;
7792
7793   va_start (ap, cmsgid);
7794   vfprintf (stderr, _(cmsgid), ap);
7795   va_end (ap);
7796 }
7797 \f
7798 static inline void
7799 validate_switches_from_spec (const char *spec)
7800 {
7801   const char *p = spec;
7802   char c;
7803   while ((c = *p++))
7804     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7805       /* We have a switch spec.  */
7806       p = validate_switches (p + 1);
7807 }
7808
7809 static void
7810 validate_all_switches (void)
7811 {
7812   struct compiler *comp;
7813   struct spec_list *spec;
7814
7815   for (comp = compilers; comp->spec; comp++)
7816     validate_switches_from_spec (comp->spec);
7817
7818   /* Look through the linked list of specs read from the specs file.  */
7819   for (spec = specs; spec; spec = spec->next)
7820     validate_switches_from_spec (*spec->ptr_spec);
7821
7822   validate_switches_from_spec (link_command_spec);
7823 }
7824
7825 /* Look at the switch-name that comes after START
7826    and mark as valid all supplied switches that match it.  */
7827
7828 static const char *
7829 validate_switches (const char *start)
7830 {
7831   const char *p = start;
7832   const char *atom;
7833   size_t len;
7834   int i;
7835   bool suffix = false;
7836   bool starred = false;
7837
7838 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7839
7840 next_member:
7841   SKIP_WHITE ();
7842
7843   if (*p == '!')
7844     p++;
7845
7846   SKIP_WHITE ();
7847   if (*p == '.' || *p == ',')
7848     suffix = true, p++;
7849
7850   atom = p;
7851   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7852          || *p == ',' || *p == '.' || *p == '@')
7853     p++;
7854   len = p - atom;
7855
7856   if (*p == '*')
7857     starred = true, p++;
7858
7859   SKIP_WHITE ();
7860
7861   if (!suffix)
7862     {
7863       /* Mark all matching switches as valid.  */
7864       for (i = 0; i < n_switches; i++)
7865         if (!strncmp (switches[i].part1, atom, len)
7866             && (starred || switches[i].part1[len] == 0))
7867           switches[i].validated = 1;
7868     }
7869
7870   if (*p) p++;
7871   if (*p && (p[-1] == '|' || p[-1] == '&'))
7872     goto next_member;
7873
7874   if (*p && p[-1] == ':')
7875     {
7876       while (*p && *p != ';' && *p != '}')
7877         {
7878           if (*p == '%')
7879             {
7880               p++;
7881               if (*p == '{' || *p == '<')
7882                 p = validate_switches (p+1);
7883               else if (p[0] == 'W' && p[1] == '{')
7884                 p = validate_switches (p+2);
7885             }
7886           else
7887             p++;
7888         }
7889
7890       if (*p) p++;
7891       if (*p && p[-1] == ';')
7892         goto next_member;
7893     }
7894
7895   return p;
7896 #undef SKIP_WHITE
7897 }
7898 \f
7899 struct mdswitchstr
7900 {
7901   const char *str;
7902   int len;
7903 };
7904
7905 static struct mdswitchstr *mdswitches;
7906 static int n_mdswitches;
7907
7908 /* Check whether a particular argument was used.  The first time we
7909    canonicalize the switches to keep only the ones we care about.  */
7910
7911 static int
7912 used_arg (const char *p, int len)
7913 {
7914   struct mswitchstr
7915   {
7916     const char *str;
7917     const char *replace;
7918     int len;
7919     int rep_len;
7920   };
7921
7922   static struct mswitchstr *mswitches;
7923   static int n_mswitches;
7924   int i, j;
7925
7926   if (!mswitches)
7927     {
7928       struct mswitchstr *matches;
7929       const char *q;
7930       int cnt = 0;
7931
7932       /* Break multilib_matches into the component strings of string
7933          and replacement string.  */
7934       for (q = multilib_matches; *q != '\0'; q++)
7935         if (*q == ';')
7936           cnt++;
7937
7938       matches
7939         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7940       i = 0;
7941       q = multilib_matches;
7942       while (*q != '\0')
7943         {
7944           matches[i].str = q;
7945           while (*q != ' ')
7946             {
7947               if (*q == '\0')
7948                 {
7949                 invalid_matches:
7950                   fatal ("multilib spec '%s' is invalid", multilib_matches);
7951                 }
7952               q++;
7953             }
7954           matches[i].len = q - matches[i].str;
7955
7956           matches[i].replace = ++q;
7957           while (*q != ';' && *q != '\0')
7958             {
7959               if (*q == ' ')
7960                 goto invalid_matches;
7961               q++;
7962             }
7963           matches[i].rep_len = q - matches[i].replace;
7964           i++;
7965           if (*q == ';')
7966             q++;
7967         }
7968
7969       /* Now build a list of the replacement string for switches that we care
7970          about.  Make sure we allocate at least one entry.  This prevents
7971          xmalloc from calling fatal, and prevents us from re-executing this
7972          block of code.  */
7973       mswitches
7974         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7975       for (i = 0; i < n_switches; i++)
7976         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7977           {
7978             int xlen = strlen (switches[i].part1);
7979             for (j = 0; j < cnt; j++)
7980               if (xlen == matches[j].len
7981                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7982                 {
7983                   mswitches[n_mswitches].str = matches[j].replace;
7984                   mswitches[n_mswitches].len = matches[j].rep_len;
7985                   mswitches[n_mswitches].replace = (char *) 0;
7986                   mswitches[n_mswitches].rep_len = 0;
7987                   n_mswitches++;
7988                   break;
7989                 }
7990           }
7991
7992       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7993          on the command line nor any options mutually incompatible with
7994          them.  */
7995       for (i = 0; i < n_mdswitches; i++)
7996         {
7997           const char *r;
7998
7999           for (q = multilib_options; *q != '\0'; q++)
8000             {
8001               while (*q == ' ')
8002                 q++;
8003
8004               r = q;
8005               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
8006                      || strchr (" /", q[mdswitches[i].len]) == NULL)
8007                 {
8008                   while (*q != ' ' && *q != '/' && *q != '\0')
8009                     q++;
8010                   if (*q != '/')
8011                     break;
8012                   q++;
8013                 }
8014
8015               if (*q != ' ' && *q != '\0')
8016                 {
8017                   while (*r != ' ' && *r != '\0')
8018                     {
8019                       q = r;
8020                       while (*q != ' ' && *q != '/' && *q != '\0')
8021                         q++;
8022
8023                       if (used_arg (r, q - r))
8024                         break;
8025
8026                       if (*q != '/')
8027                         {
8028                           mswitches[n_mswitches].str = mdswitches[i].str;
8029                           mswitches[n_mswitches].len = mdswitches[i].len;
8030                           mswitches[n_mswitches].replace = (char *) 0;
8031                           mswitches[n_mswitches].rep_len = 0;
8032                           n_mswitches++;
8033                           break;
8034                         }
8035
8036                       r = q + 1;
8037                     }
8038                   break;
8039                 }
8040             }
8041         }
8042     }
8043
8044   for (i = 0; i < n_mswitches; i++)
8045     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
8046       return 1;
8047
8048   return 0;
8049 }
8050
8051 static int
8052 default_arg (const char *p, int len)
8053 {
8054   int i;
8055
8056   for (i = 0; i < n_mdswitches; i++)
8057     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
8058       return 1;
8059
8060   return 0;
8061 }
8062
8063 /* Work out the subdirectory to use based on the options. The format of
8064    multilib_select is a list of elements. Each element is a subdirectory
8065    name followed by a list of options followed by a semicolon. The format
8066    of multilib_exclusions is the same, but without the preceding
8067    directory. First gcc will check the exclusions, if none of the options
8068    beginning with an exclamation point are present, and all of the other
8069    options are present, then we will ignore this completely. Passing
8070    that, gcc will consider each multilib_select in turn using the same
8071    rules for matching the options. If a match is found, that subdirectory
8072    will be used.  */
8073
8074 static void
8075 set_multilib_dir (void)
8076 {
8077   const char *p;
8078   unsigned int this_path_len;
8079   const char *this_path, *this_arg;
8080   const char *start, *end;
8081   int not_arg;
8082   int ok, ndfltok, first;
8083
8084   n_mdswitches = 0;
8085   start = multilib_defaults;
8086   while (*start == ' ' || *start == '\t')
8087     start++;
8088   while (*start != '\0')
8089     {
8090       n_mdswitches++;
8091       while (*start != ' ' && *start != '\t' && *start != '\0')
8092         start++;
8093       while (*start == ' ' || *start == '\t')
8094         start++;
8095     }
8096
8097   if (n_mdswitches)
8098     {
8099       int i = 0;
8100
8101       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8102       for (start = multilib_defaults; *start != '\0'; start = end + 1)
8103         {
8104           while (*start == ' ' || *start == '\t')
8105             start++;
8106
8107           if (*start == '\0')
8108             break;
8109
8110           for (end = start + 1;
8111                *end != ' ' && *end != '\t' && *end != '\0'; end++)
8112             ;
8113
8114           obstack_grow (&multilib_obstack, start, end - start);
8115           obstack_1grow (&multilib_obstack, 0);
8116           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8117           mdswitches[i++].len = end - start;
8118
8119           if (*end == '\0')
8120             break;
8121         }
8122     }
8123
8124   p = multilib_exclusions;
8125   while (*p != '\0')
8126     {
8127       /* Ignore newlines.  */
8128       if (*p == '\n')
8129         {
8130           ++p;
8131           continue;
8132         }
8133
8134       /* Check the arguments.  */
8135       ok = 1;
8136       while (*p != ';')
8137         {
8138           if (*p == '\0')
8139             {
8140             invalid_exclusions:
8141               fatal ("multilib exclusions '%s' is invalid",
8142                      multilib_exclusions);
8143             }
8144
8145           if (! ok)
8146             {
8147               ++p;
8148               continue;
8149             }
8150
8151           this_arg = p;
8152           while (*p != ' ' && *p != ';')
8153             {
8154               if (*p == '\0')
8155                 goto invalid_exclusions;
8156               ++p;
8157             }
8158
8159           if (*this_arg != '!')
8160             not_arg = 0;
8161           else
8162             {
8163               not_arg = 1;
8164               ++this_arg;
8165             }
8166
8167           ok = used_arg (this_arg, p - this_arg);
8168           if (not_arg)
8169             ok = ! ok;
8170
8171           if (*p == ' ')
8172             ++p;
8173         }
8174
8175       if (ok)
8176         return;
8177
8178       ++p;
8179     }
8180
8181   first = 1;
8182   p = multilib_select;
8183   while (*p != '\0')
8184     {
8185       /* Ignore newlines.  */
8186       if (*p == '\n')
8187         {
8188           ++p;
8189           continue;
8190         }
8191
8192       /* Get the initial path.  */
8193       this_path = p;
8194       while (*p != ' ')
8195         {
8196           if (*p == '\0')
8197             {
8198             invalid_select:
8199               fatal ("multilib select '%s' is invalid",
8200                      multilib_select);
8201             }
8202           ++p;
8203         }
8204       this_path_len = p - this_path;
8205
8206       /* Check the arguments.  */
8207       ok = 1;
8208       ndfltok = 1;
8209       ++p;
8210       while (*p != ';')
8211         {
8212           if (*p == '\0')
8213             goto invalid_select;
8214
8215           if (! ok)
8216             {
8217               ++p;
8218               continue;
8219             }
8220
8221           this_arg = p;
8222           while (*p != ' ' && *p != ';')
8223             {
8224               if (*p == '\0')
8225                 goto invalid_select;
8226               ++p;
8227             }
8228
8229           if (*this_arg != '!')
8230             not_arg = 0;
8231           else
8232             {
8233               not_arg = 1;
8234               ++this_arg;
8235             }
8236
8237           /* If this is a default argument, we can just ignore it.
8238              This is true even if this_arg begins with '!'.  Beginning
8239              with '!' does not mean that this argument is necessarily
8240              inappropriate for this library: it merely means that
8241              there is a more specific library which uses this
8242              argument.  If this argument is a default, we need not
8243              consider that more specific library.  */
8244           ok = used_arg (this_arg, p - this_arg);
8245           if (not_arg)
8246             ok = ! ok;
8247
8248           if (! ok)
8249             ndfltok = 0;
8250
8251           if (default_arg (this_arg, p - this_arg))
8252             ok = 1;
8253
8254           if (*p == ' ')
8255             ++p;
8256         }
8257
8258       if (ok && first)
8259         {
8260           if (this_path_len != 1
8261               || this_path[0] != '.')
8262             {
8263               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8264               char *q;
8265
8266               strncpy (new_multilib_dir, this_path, this_path_len);
8267               new_multilib_dir[this_path_len] = '\0';
8268               q = strchr (new_multilib_dir, ':');
8269               if (q != NULL)
8270                 *q = '\0';
8271               multilib_dir = new_multilib_dir;
8272             }
8273           first = 0;
8274         }
8275
8276       if (ndfltok)
8277         {
8278           const char *q = this_path, *end = this_path + this_path_len;
8279
8280           while (q < end && *q != ':')
8281             q++;
8282           if (q < end)
8283             {
8284               char *new_multilib_os_dir = XNEWVEC (char, end - q);
8285               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8286               new_multilib_os_dir[end - q - 1] = '\0';
8287               multilib_os_dir = new_multilib_os_dir;
8288               break;
8289             }
8290         }
8291
8292       ++p;
8293     }
8294
8295   if (multilib_dir == NULL && multilib_os_dir != NULL
8296       && strcmp (multilib_os_dir, ".") == 0)
8297     {
8298       free (CONST_CAST (char *, multilib_os_dir));
8299       multilib_os_dir = NULL;
8300     }
8301   else if (multilib_dir != NULL && multilib_os_dir == NULL)
8302     multilib_os_dir = multilib_dir;
8303 }
8304
8305 /* Print out the multiple library subdirectory selection
8306    information.  This prints out a series of lines.  Each line looks
8307    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8308    required.  Only the desired options are printed out, the negative
8309    matches.  The options are print without a leading dash.  There are
8310    no spaces to make it easy to use the information in the shell.
8311    Each subdirectory is printed only once.  This assumes the ordering
8312    generated by the genmultilib script. Also, we leave out ones that match
8313    the exclusions.  */
8314
8315 static void
8316 print_multilib_info (void)
8317 {
8318   const char *p = multilib_select;
8319   const char *last_path = 0, *this_path;
8320   int skip;
8321   unsigned int last_path_len = 0;
8322
8323   while (*p != '\0')
8324     {
8325       skip = 0;
8326       /* Ignore newlines.  */
8327       if (*p == '\n')
8328         {
8329           ++p;
8330           continue;
8331         }
8332
8333       /* Get the initial path.  */
8334       this_path = p;
8335       while (*p != ' ')
8336         {
8337           if (*p == '\0')
8338             {
8339             invalid_select:
8340               fatal ("multilib select '%s' is invalid", multilib_select);
8341             }
8342
8343           ++p;
8344         }
8345
8346       /* When --disable-multilib was used but target defines
8347          MULTILIB_OSDIRNAMES, entries starting with .: are there just
8348          to find multilib_os_dir, so skip them from output.  */
8349       if (this_path[0] == '.' && this_path[1] == ':')
8350         skip = 1;
8351
8352       /* Check for matches with the multilib_exclusions. We don't bother
8353          with the '!' in either list. If any of the exclusion rules match
8354          all of its options with the select rule, we skip it.  */
8355       {
8356         const char *e = multilib_exclusions;
8357         const char *this_arg;
8358
8359         while (*e != '\0')
8360           {
8361             int m = 1;
8362             /* Ignore newlines.  */
8363             if (*e == '\n')
8364               {
8365                 ++e;
8366                 continue;
8367               }
8368
8369             /* Check the arguments.  */
8370             while (*e != ';')
8371               {
8372                 const char *q;
8373                 int mp = 0;
8374
8375                 if (*e == '\0')
8376                   {
8377                   invalid_exclusion:
8378                     fatal ("multilib exclusion '%s' is invalid",
8379                            multilib_exclusions);
8380                   }
8381
8382                 if (! m)
8383                   {
8384                     ++e;
8385                     continue;
8386                   }
8387
8388                 this_arg = e;
8389
8390                 while (*e != ' ' && *e != ';')
8391                   {
8392                     if (*e == '\0')
8393                       goto invalid_exclusion;
8394                     ++e;
8395                   }
8396
8397                 q = p + 1;
8398                 while (*q != ';')
8399                   {
8400                     const char *arg;
8401                     int len = e - this_arg;
8402
8403                     if (*q == '\0')
8404                       goto invalid_select;
8405
8406                     arg = q;
8407
8408                     while (*q != ' ' && *q != ';')
8409                       {
8410                         if (*q == '\0')
8411                           goto invalid_select;
8412                         ++q;
8413                       }
8414
8415                     if (! strncmp (arg, this_arg,
8416                                    (len < q - arg) ? q - arg : len)
8417                         || default_arg (this_arg, e - this_arg))
8418                       {
8419                         mp = 1;
8420                         break;
8421                       }
8422
8423                     if (*q == ' ')
8424                       ++q;
8425                   }
8426
8427                 if (! mp)
8428                   m = 0;
8429
8430                 if (*e == ' ')
8431                   ++e;
8432               }
8433
8434             if (m)
8435               {
8436                 skip = 1;
8437                 break;
8438               }
8439
8440             if (*e != '\0')
8441               ++e;
8442           }
8443       }
8444
8445       if (! skip)
8446         {
8447           /* If this is a duplicate, skip it.  */
8448           skip = (last_path != 0
8449                   && (unsigned int) (p - this_path) == last_path_len
8450                   && ! strncmp (last_path, this_path, last_path_len));
8451
8452           last_path = this_path;
8453           last_path_len = p - this_path;
8454         }
8455
8456       /* If this directory requires any default arguments, we can skip
8457          it.  We will already have printed a directory identical to
8458          this one which does not require that default argument.  */
8459       if (! skip)
8460         {
8461           const char *q;
8462
8463           q = p + 1;
8464           while (*q != ';')
8465             {
8466               const char *arg;
8467
8468               if (*q == '\0')
8469                 goto invalid_select;
8470
8471               if (*q == '!')
8472                 arg = NULL;
8473               else
8474                 arg = q;
8475
8476               while (*q != ' ' && *q != ';')
8477                 {
8478                   if (*q == '\0')
8479                     goto invalid_select;
8480                   ++q;
8481                 }
8482
8483               if (arg != NULL
8484                   && default_arg (arg, q - arg))
8485                 {
8486                   skip = 1;
8487                   break;
8488                 }
8489
8490               if (*q == ' ')
8491                 ++q;
8492             }
8493         }
8494
8495       if (! skip)
8496         {
8497           const char *p1;
8498
8499           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8500             putchar (*p1);
8501           putchar (';');
8502         }
8503
8504       ++p;
8505       while (*p != ';')
8506         {
8507           int use_arg;
8508
8509           if (*p == '\0')
8510             goto invalid_select;
8511
8512           if (skip)
8513             {
8514               ++p;
8515               continue;
8516             }
8517
8518           use_arg = *p != '!';
8519
8520           if (use_arg)
8521             putchar ('@');
8522
8523           while (*p != ' ' && *p != ';')
8524             {
8525               if (*p == '\0')
8526                 goto invalid_select;
8527               if (use_arg)
8528                 putchar (*p);
8529               ++p;
8530             }
8531
8532           if (*p == ' ')
8533             ++p;
8534         }
8535
8536       if (! skip)
8537         {
8538           /* If there are extra options, print them now.  */
8539           if (multilib_extra && *multilib_extra)
8540             {
8541               int print_at = TRUE;
8542               const char *q;
8543
8544               for (q = multilib_extra; *q != '\0'; q++)
8545                 {
8546                   if (*q == ' ')
8547                     print_at = TRUE;
8548                   else
8549                     {
8550                       if (print_at)
8551                         putchar ('@');
8552                       putchar (*q);
8553                       print_at = FALSE;
8554                     }
8555                 }
8556             }
8557
8558           putchar ('\n');
8559         }
8560
8561       ++p;
8562     }
8563 }
8564 \f
8565 /* getenv built-in spec function.
8566
8567    Returns the value of the environment variable given by its first
8568    argument, concatenated with the second argument.  If the
8569    environment variable is not defined, a fatal error is issued.  */
8570
8571 static const char *
8572 getenv_spec_function (int argc, const char **argv)
8573 {
8574   char *value;
8575   char *result;
8576   char *ptr;
8577   size_t len;
8578
8579   if (argc != 2)
8580     return NULL;
8581
8582   value = getenv (argv[0]);
8583   if (!value)
8584     fatal ("environment variable \"%s\" not defined", argv[0]);
8585
8586   /* We have to escape every character of the environment variable so
8587      they are not interpreted as active spec characters.  A
8588      particularly painful case is when we are reading a variable
8589      holding a windows path complete with \ separators.  */
8590   len = strlen (value) * 2 + strlen (argv[1]) + 1;
8591   result = XNEWVAR (char, len);
8592   for (ptr = result; *value; ptr += 2)
8593     {
8594       ptr[0] = '\\';
8595       ptr[1] = *value++;
8596     }
8597
8598   strcpy (ptr, argv[1]);
8599
8600   return result;
8601 }
8602
8603 /* if-exists built-in spec function.
8604
8605    Checks to see if the file specified by the absolute pathname in
8606    ARGS exists.  Returns that pathname if found.
8607
8608    The usual use for this function is to check for a library file
8609    (whose name has been expanded with %s).  */
8610
8611 static const char *
8612 if_exists_spec_function (int argc, const char **argv)
8613 {
8614   /* Must have only one argument.  */
8615   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8616     return argv[0];
8617
8618   return NULL;
8619 }
8620
8621 /* if-exists-else built-in spec function.
8622
8623    This is like if-exists, but takes an additional argument which
8624    is returned if the first argument does not exist.  */
8625
8626 static const char *
8627 if_exists_else_spec_function (int argc, const char **argv)
8628 {
8629   /* Must have exactly two arguments.  */
8630   if (argc != 2)
8631     return NULL;
8632
8633   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8634     return argv[0];
8635
8636   return argv[1];
8637 }
8638
8639 /* replace-outfile built-in spec function.
8640
8641    This looks for the first argument in the outfiles array's name and
8642    replaces it with the second argument.  */
8643
8644 static const char *
8645 replace_outfile_spec_function (int argc, const char **argv)
8646 {
8647   int i;
8648   /* Must have exactly two arguments.  */
8649   if (argc != 2)
8650     abort ();
8651
8652   for (i = 0; i < n_infiles; i++)
8653     {
8654       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8655         outfiles[i] = xstrdup (argv[1]);
8656     }
8657   return NULL;
8658 }
8659
8660 /* Given two version numbers, compares the two numbers.
8661    A version number must match the regular expression
8662    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8663 */
8664 static int
8665 compare_version_strings (const char *v1, const char *v2)
8666 {
8667   int rresult;
8668   regex_t r;
8669
8670   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8671                REG_EXTENDED | REG_NOSUB) != 0)
8672     abort ();
8673   rresult = regexec (&r, v1, 0, NULL, 0);
8674   if (rresult == REG_NOMATCH)
8675     fatal ("invalid version number `%s'", v1);
8676   else if (rresult != 0)
8677     abort ();
8678   rresult = regexec (&r, v2, 0, NULL, 0);
8679   if (rresult == REG_NOMATCH)
8680     fatal ("invalid version number `%s'", v2);
8681   else if (rresult != 0)
8682     abort ();
8683
8684   return strverscmp (v1, v2);
8685 }
8686
8687
8688 /* version_compare built-in spec function.
8689
8690    This takes an argument of the following form:
8691
8692    <comparison-op> <arg1> [<arg2>] <switch> <result>
8693
8694    and produces "result" if the comparison evaluates to true,
8695    and nothing if it doesn't.
8696
8697    The supported <comparison-op> values are:
8698
8699    >=  true if switch is a later (or same) version than arg1
8700    !>  opposite of >=
8701    <   true if switch is an earlier version than arg1
8702    !<  opposite of <
8703    ><  true if switch is arg1 or later, and earlier than arg2
8704    <>  true if switch is earlier than arg1 or is arg2 or later
8705
8706    If the switch is not present, the condition is false unless
8707    the first character of the <comparison-op> is '!'.
8708
8709    For example,
8710    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8711    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
8712
8713 static const char *
8714 version_compare_spec_function (int argc, const char **argv)
8715 {
8716   int comp1, comp2;
8717   size_t switch_len;
8718   const char *switch_value = NULL;
8719   int nargs = 1, i;
8720   bool result;
8721
8722   if (argc < 3)
8723     fatal ("too few arguments to %%:version-compare");
8724   if (argv[0][0] == '\0')
8725     abort ();
8726   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8727     nargs = 2;
8728   if (argc != nargs + 3)
8729     fatal ("too many arguments to %%:version-compare");
8730
8731   switch_len = strlen (argv[nargs + 1]);
8732   for (i = 0; i < n_switches; i++)
8733     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8734         && check_live_switch (i, switch_len))
8735       switch_value = switches[i].part1 + switch_len;
8736
8737   if (switch_value == NULL)
8738     comp1 = comp2 = -1;
8739   else
8740     {
8741       comp1 = compare_version_strings (switch_value, argv[1]);
8742       if (nargs == 2)
8743         comp2 = compare_version_strings (switch_value, argv[2]);
8744       else
8745         comp2 = -1;  /* This value unused.  */
8746     }
8747
8748   switch (argv[0][0] << 8 | argv[0][1])
8749     {
8750     case '>' << 8 | '=':
8751       result = comp1 >= 0;
8752       break;
8753     case '!' << 8 | '<':
8754       result = comp1 >= 0 || switch_value == NULL;
8755       break;
8756     case '<' << 8:
8757       result = comp1 < 0;
8758       break;
8759     case '!' << 8 | '>':
8760       result = comp1 < 0 || switch_value == NULL;
8761       break;
8762     case '>' << 8 | '<':
8763       result = comp1 >= 0 && comp2 < 0;
8764       break;
8765     case '<' << 8 | '>':
8766       result = comp1 < 0 || comp2 >= 0;
8767       break;
8768
8769     default:
8770       fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8771     }
8772   if (! result)
8773     return NULL;
8774
8775   return argv[nargs + 2];
8776 }
8777
8778 /* %:include builtin spec function.  This differs from %include in that it
8779    can be nested inside a spec, and thus be conditionalized.  It takes
8780    one argument, the filename, and looks for it in the startfile path.
8781    The result is always NULL, i.e. an empty expansion.  */
8782
8783 static const char *
8784 include_spec_function (int argc, const char **argv)
8785 {
8786   char *file;
8787
8788   if (argc != 1)
8789     abort ();
8790
8791   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8792   read_specs (file ? file : argv[0], FALSE);
8793
8794   return NULL;
8795 }
8796
8797 /* %:print-asm-header spec function.  Print a banner to say that the
8798    following output is from the assembler.  */
8799
8800 static const char *
8801 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8802                                 const char **argv ATTRIBUTE_UNUSED)
8803 {
8804   printf (_("Assembler options\n=================\n\n"));
8805   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8806   fflush (stdout);
8807   return NULL;
8808 }
8809
8810 /* Compute a timestamp to initialize flag_random_seed.  */
8811
8812 static unsigned
8813 get_local_tick (void)
8814 {
8815   unsigned ret = 0;
8816
8817   /* Get some more or less random data.  */
8818 #ifdef HAVE_GETTIMEOFDAY
8819   {
8820     struct timeval tv;
8821
8822     gettimeofday (&tv, NULL);
8823     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8824   }
8825 #else
8826   {
8827     time_t now = time (NULL);
8828
8829     if (now != (time_t)-1)
8830       ret = (unsigned) now;
8831   }
8832 #endif
8833
8834   return ret;
8835 }
8836
8837 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8838    expected to be the last -fdump-final-insns option, or generate a
8839    temporary.  */
8840
8841 static const char *
8842 compare_debug_dump_opt_spec_function (int arg,
8843                                       const char **argv ATTRIBUTE_UNUSED)
8844 {
8845   const char *ret;
8846   char *name;
8847   int which;
8848   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8849
8850   if (arg != 0)
8851     fatal ("too many arguments to %%:compare-debug-dump-opt");
8852
8853   do_spec_2 ("%{fdump-final-insns=*:%*}");
8854   do_spec_1 (" ", 0, NULL);
8855
8856   if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8857     {
8858       if (!compare_debug)
8859         return NULL;
8860
8861       name = xstrdup (argv[argbuf_index - 1]);
8862       ret = NULL;
8863     }
8864   else
8865     {
8866       const char *ext = NULL;
8867
8868       if (argbuf_index > 0)
8869         {
8870           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8871           ext = ".gkd";
8872         }
8873       else if (!compare_debug)
8874         return NULL;
8875       else
8876         do_spec_2 ("%g.gkd");
8877
8878       do_spec_1 (" ", 0, NULL);
8879
8880       gcc_assert (argbuf_index > 0);
8881
8882       name = concat (argbuf[argbuf_index - 1], ext, NULL);
8883
8884       ret = concat ("-fdump-final-insns=", name, NULL);
8885     }
8886
8887   which = compare_debug < 0;
8888   debug_check_temp_file[which] = name;
8889
8890   if (!which)
8891     {
8892       unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8893
8894       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8895     }
8896
8897   if (*random_seed)
8898     ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8899                   ret, NULL);
8900
8901   if (which)
8902     *random_seed = 0;
8903
8904   return ret;
8905 }
8906
8907 static const char *debug_auxbase_opt;
8908
8909 /* %:compare-debug-self-opt spec function.  Expands to the options
8910     that are to be passed in the second compilation of
8911     compare-debug.  */
8912
8913 static const char *
8914 compare_debug_self_opt_spec_function (int arg,
8915                                       const char **argv ATTRIBUTE_UNUSED)
8916 {
8917   if (arg != 0)
8918     fatal ("too many arguments to %%:compare-debug-self-opt");
8919
8920   if (compare_debug >= 0)
8921     return NULL;
8922
8923   do_spec_2 ("%{c|S:%{o*:%*}}");
8924   do_spec_1 (" ", 0, NULL);
8925
8926   if (argbuf_index > 0)
8927     debug_auxbase_opt = concat ("-auxbase-strip ",
8928                                 argbuf[argbuf_index - 1],
8929                                 NULL);
8930   else
8931     debug_auxbase_opt = NULL;
8932
8933   return concat ("\
8934 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8935 %<fdump-final-insns=* -w -S -o %j \
8936 %{!fcompare-debug-second:-fcompare-debug-second} \
8937 ", compare_debug_opt, NULL);
8938 }
8939
8940 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8941     options that are to be passed in the second compilation of
8942     compare-debug.  It expects, as an argument, the basename of the
8943     current input file name, with the .gk suffix appended to it.  */
8944
8945 static const char *
8946 compare_debug_auxbase_opt_spec_function (int arg,
8947                                          const char **argv)
8948 {
8949   char *name;
8950   int len;
8951
8952   if (arg == 0)
8953     fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8954
8955   if (arg != 1)
8956     fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8957
8958   if (compare_debug >= 0)
8959     return NULL;
8960
8961   len = strlen (argv[0]);
8962   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8963     fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8964
8965   if (debug_auxbase_opt)
8966     return debug_auxbase_opt;
8967
8968 #define OPT "-auxbase "
8969
8970   len -= 3;
8971   name = (char*) xmalloc (sizeof (OPT) + len);
8972   memcpy (name, OPT, sizeof (OPT) - 1);
8973   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8974   name[sizeof (OPT) - 1 + len] = '\0';
8975
8976 #undef OPT
8977
8978   return name;
8979 }