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