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