gcc/gcc.c

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