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_DIRECTORY_STRUCTURE
 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-strong|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_DIRECTORY_STRUCTURE  /* 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 #ifdef FREEBSD_NATIVE
2700   if (! strcmp(name, "include"))
2701     {
2702 #ifdef CROSS_INCLUDE_DIR
2703       return xstrdup(CROSS_INCLUDE_DIR);
2704 #else
2705       return xstrdup(STANDARD_INCLUDE_DIR);
2706 #endif
2707     }
2708 #endif
2709
2710   /* Determine the filename to execute (special case for absolute paths).  */
2711
2712   if (IS_ABSOLUTE_PATH (name))
2713     {
2714       if (access (name, mode) == 0)
2715         return xstrdup (name);
2716
2717       return NULL;
2718     }
2719
2720   info.name = name;
2721   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2722   info.name_len = strlen (info.name);
2723   info.suffix_len = strlen (info.suffix);
2724   info.mode = mode;
2725
2726   return for_each_path (pprefix, do_multi, info.name_len + info.suffix_len,
2727                         file_at_path, &info);
2728 }
2729
2730 /* Ranking of prefixes in the sort list. -B prefixes are put before
2731    all others.  */
2732
2733 enum path_prefix_priority
2734 {
2735   PREFIX_PRIORITY_B_OPT,
2736   PREFIX_PRIORITY_LAST
2737 };
2738
2739 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2740    order according to PRIORITY.  Within each PRIORITY, new entries are
2741    appended.
2742
2743    If WARN is nonzero, we will warn if no file is found
2744    through this prefix.  WARN should point to an int
2745    which will be set to 1 if this entry is used.
2746
2747    COMPONENT is the value to be passed to update_path.
2748
2749    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2750    the complete value of machine_suffix.
2751    2 means try both machine_suffix and just_machine_suffix.  */
2752
2753 static void
2754 add_prefix (struct path_prefix *pprefix, const char *prefix,
2755             const char *component, /* enum prefix_priority */ int priority,
2756             int require_machine_suffix, int os_multilib)
2757 {
2758   struct prefix_list *pl, **prev;
2759   int len;
2760
2761   for (prev = &pprefix->plist;
2762        (*prev) != NULL && (*prev)->priority <= priority;
2763        prev = &(*prev)->next)
2764     ;
2765
2766   /* Keep track of the longest prefix.  */
2767
2768   prefix = update_path (prefix, component);
2769   len = strlen (prefix);
2770   if (len > pprefix->max_len)
2771     pprefix->max_len = len;
2772
2773   pl = XNEW (struct prefix_list);
2774   pl->prefix = prefix;
2775   pl->require_machine_suffix = require_machine_suffix;
2776   pl->priority = priority;
2777   pl->os_multilib = os_multilib;
2778
2779   /* Insert after PREV.  */
2780   pl->next = (*prev);
2781   (*prev) = pl;
2782 }
2783
2784 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2785 static void
2786 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2787                       const char *component,
2788                       /* enum prefix_priority */ int priority,
2789                       int require_machine_suffix, int os_multilib)
2790 {
2791   if (!IS_ABSOLUTE_PATH (prefix))
2792     fatal ("system path '%s' is not absolute", prefix);
2793
2794   if (target_system_root)
2795     {
2796       if (target_sysroot_suffix)
2797           prefix = concat (target_sysroot_suffix, prefix, NULL);
2798       prefix = concat (target_system_root, prefix, NULL);
2799
2800       /* We have to override this because GCC's notion of sysroot
2801          moves along with GCC.  */
2802       component = "GCC";
2803     }
2804
2805   add_prefix (pprefix, prefix, component, priority,
2806               require_machine_suffix, os_multilib);
2807 }
2808 \f
2809 /* Execute the command specified by the arguments on the current line of spec.
2810    When using pipes, this includes several piped-together commands
2811    with `|' between them.
2812
2813    Return 0 if successful, -1 if failed.  */
2814
2815 static int
2816 execute (void)
2817 {
2818   int i;
2819   int n_commands;               /* # of command.  */
2820   char *string;
2821   struct pex_obj *pex;
2822   struct command
2823   {
2824     const char *prog;           /* program name.  */
2825     const char **argv;          /* vector of args.  */
2826   };
2827
2828   struct command *commands;     /* each command buffer with above info.  */
2829
2830   gcc_assert (!processing_spec_function);
2831
2832   /* Count # of piped commands.  */
2833   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2834     if (strcmp (argbuf[i], "|") == 0)
2835       n_commands++;
2836
2837   /* Get storage for each command.  */
2838   commands = alloca (n_commands * sizeof (struct command));
2839
2840   /* Split argbuf into its separate piped processes,
2841      and record info about each one.
2842      Also search for the programs that are to be run.  */
2843
2844   commands[0].prog = argbuf[0]; /* first command.  */
2845   commands[0].argv = &argbuf[0];
2846   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2847
2848   if (string)
2849     commands[0].argv[0] = string;
2850
2851   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2852     if (strcmp (argbuf[i], "|") == 0)
2853       {                         /* each command.  */
2854 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2855         fatal ("-pipe not supported");
2856 #endif
2857         argbuf[i] = 0;  /* termination of command args.  */
2858         commands[n_commands].prog = argbuf[i + 1];
2859         commands[n_commands].argv = &argbuf[i + 1];
2860         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2861                               X_OK, false);
2862         if (string)
2863           commands[n_commands].argv[0] = string;
2864         n_commands++;
2865       }
2866
2867   argbuf[argbuf_index] = 0;
2868
2869   /* If -v, print what we are about to do, and maybe query.  */
2870
2871   if (verbose_flag)
2872     {
2873       /* For help listings, put a blank line between sub-processes.  */
2874       if (print_help_list)
2875         fputc ('\n', stderr);
2876
2877       /* Print each piped command as a separate line.  */
2878       for (i = 0; i < n_commands; i++)
2879         {
2880           const char *const *j;
2881
2882           if (verbose_only_flag)
2883             {
2884               for (j = commands[i].argv; *j; j++)
2885                 {
2886                   const char *p;
2887                   fprintf (stderr, " \"");
2888                   for (p = *j; *p; ++p)
2889                     {
2890                       if (*p == '"' || *p == '\\' || *p == '$')
2891                         fputc ('\\', stderr);
2892                       fputc (*p, stderr);
2893                     }
2894                   fputc ('"', stderr);
2895                 }
2896             }
2897           else
2898             for (j = commands[i].argv; *j; j++)
2899               fprintf (stderr, " %s", *j);
2900
2901           /* Print a pipe symbol after all but the last command.  */
2902           if (i + 1 != n_commands)
2903             fprintf (stderr, " |");
2904           fprintf (stderr, "\n");
2905         }
2906       fflush (stderr);
2907       if (verbose_only_flag != 0)
2908         {
2909           /* verbose_only_flag should act as if the spec was
2910              executed, so increment execution_count before
2911              returning.  This prevents spurious warnings about
2912              unused linker input files, etc.  */
2913           execution_count++;
2914           return 0;
2915         }
2916 #ifdef DEBUG
2917       notice ("\nGo ahead? (y or n) ");
2918       fflush (stderr);
2919       i = getchar ();
2920       if (i != '\n')
2921         while (getchar () != '\n')
2922           ;
2923
2924       if (i != 'y' && i != 'Y')
2925         return 0;
2926 #endif /* DEBUG */
2927     }
2928
2929 #ifdef ENABLE_VALGRIND_CHECKING
2930   /* Run the each command through valgrind.  To simplify prepending the
2931      path to valgrind and the option "-q" (for quiet operation unless
2932      something triggers), we allocate a separate argv array.  */
2933
2934   for (i = 0; i < n_commands; i++)
2935     {
2936       const char **argv;
2937       int argc;
2938       int j;
2939
2940       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2941         ;
2942
2943       argv = alloca ((argc + 3) * sizeof (char *));
2944
2945       argv[0] = VALGRIND_PATH;
2946       argv[1] = "-q";
2947       for (j = 2; j < argc + 2; j++)
2948         argv[j] = commands[i].argv[j - 2];
2949       argv[j] = NULL;
2950
2951       commands[i].argv = argv;
2952       commands[i].prog = argv[0];
2953     }
2954 #endif
2955
2956   /* Run each piped subprocess.  */
2957
2958   pex = pex_init (PEX_USE_PIPES | (report_times ? PEX_RECORD_TIMES : 0),
2959                   programname, temp_filename);
2960   if (pex == NULL)
2961     pfatal_with_name (_("pex_init failed"));
2962
2963   for (i = 0; i < n_commands; i++)
2964     {
2965       const char *errmsg;
2966       int err;
2967       const char *string = commands[i].argv[0];
2968
2969       errmsg = pex_run (pex,
2970                         ((i + 1 == n_commands ? PEX_LAST : 0)
2971                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2972                         string, (char * const *) commands[i].argv,
2973                         NULL, NULL, &err);
2974       if (errmsg != NULL)
2975         {
2976           if (err == 0)
2977             fatal ("%s", errmsg);
2978           else
2979             {
2980               errno = err;
2981               pfatal_with_name (errmsg);
2982             }
2983         }
2984
2985       if (string != commands[i].prog)
2986         free ((void *) string);
2987     }
2988
2989   execution_count++;
2990
2991   /* Wait for all the subprocesses to finish.  */
2992
2993   {
2994     int *statuses;
2995     struct pex_time *times = NULL;
2996     int ret_code = 0;
2997
2998     statuses = alloca (n_commands * sizeof (int));
2999     if (!pex_get_status (pex, n_commands, statuses))
3000       pfatal_with_name (_("failed to get exit status"));
3001
3002     if (report_times)
3003       {
3004         times = alloca (n_commands * sizeof (struct pex_time));
3005         if (!pex_get_times (pex, n_commands, times))
3006           pfatal_with_name (_("failed to get process times"));
3007       }
3008
3009     pex_free (pex);
3010
3011     for (i = 0; i < n_commands; ++i)
3012       {
3013         int status = statuses[i];
3014
3015         if (WIFSIGNALED (status))
3016           {
3017 #ifdef SIGPIPE
3018             /* SIGPIPE is a special case.  It happens in -pipe mode
3019                when the compiler dies before the preprocessor is done,
3020                or the assembler dies before the compiler is done.
3021                There's generally been an error already, and this is
3022                just fallout.  So don't generate another error unless
3023                we would otherwise have succeeded.  */
3024             if (WTERMSIG (status) == SIGPIPE
3025                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3026               {
3027                 signal_count++;
3028                 ret_code = -1;
3029               }
3030             else
3031 #endif
3032               fatal_ice ("\
3033 Internal error: %s (program %s)\n\
3034 Please submit a full bug report.\n\
3035 See %s for instructions.",
3036                         strsignal (WTERMSIG (status)), commands[i].prog,
3037                         bug_report_url);
3038           }
3039         else if (WIFEXITED (status)
3040                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3041           {
3042             if (WEXITSTATUS (status) > greatest_status)
3043               greatest_status = WEXITSTATUS (status);
3044             ret_code = -1;
3045           }
3046
3047         if (report_times)
3048           {
3049             struct pex_time *pt = &times[i];
3050             double ut, st;
3051
3052             ut = ((double) pt->user_seconds
3053                   + (double) pt->user_microseconds / 1.0e6);
3054             st = ((double) pt->system_seconds
3055                   + (double) pt->system_microseconds / 1.0e6);
3056
3057             if (ut + st != 0)
3058               notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3059           }
3060       }
3061
3062     return ret_code;
3063   }
3064 }
3065 \f
3066 /* Find all the switches given to us
3067    and make a vector describing them.
3068    The elements of the vector are strings, one per switch given.
3069    If a switch uses following arguments, then the `part1' field
3070    is the switch itself and the `args' field
3071    is a null-terminated vector containing the following arguments.
3072    The `live_cond' field is:
3073    0 when initialized
3074    1 if the switch is true in a conditional spec,
3075    -1 if false (overridden by a later switch)
3076    -2 if this switch should be ignored (used in %<S)
3077    The `validated' field is nonzero if any spec has looked at this switch;
3078    if it remains zero at the end of the run, it must be meaningless.  */
3079
3080 #define SWITCH_OK       0
3081 #define SWITCH_FALSE   -1
3082 #define SWITCH_IGNORE  -2
3083 #define SWITCH_LIVE     1
3084
3085 struct switchstr
3086 {
3087   const char *part1;
3088   const char **args;
3089   int live_cond;
3090   unsigned char validated;
3091   unsigned char ordering;
3092 };
3093
3094 static struct switchstr *switches;
3095
3096 static int n_switches;
3097
3098 /* Language is one of three things:
3099
3100    1) The name of a real programming language.
3101    2) NULL, indicating that no one has figured out
3102    what it is yet.
3103    3) '*', indicating that the file should be passed
3104    to the linker.  */
3105 struct infile
3106 {
3107   const char *name;
3108   const char *language;
3109   struct compiler *incompiler;
3110   bool compiled;
3111   bool preprocessed;
3112 };
3113
3114 /* Also a vector of input files specified.  */
3115
3116 static struct infile *infiles;
3117
3118 int n_infiles;
3119
3120 /* True if multiple input files are being compiled to a single
3121    assembly file.  */
3122
3123 static bool combine_inputs;
3124
3125 /* This counts the number of libraries added by lang_specific_driver, so that
3126    we can tell if there were any user supplied any files or libraries.  */
3127
3128 static int added_libraries;
3129
3130 /* And a vector of corresponding output files is made up later.  */
3131
3132 const char **outfiles;
3133 \f
3134 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3135
3136 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
3137    is true if we should look for an executable suffix.  DO_OBJ
3138    is true if we should look for an object suffix.  */
3139
3140 static const char *
3141 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3142                   int do_obj ATTRIBUTE_UNUSED)
3143 {
3144 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3145   int i;
3146 #endif
3147   int len;
3148
3149   if (name == NULL)
3150     return NULL;
3151
3152   len = strlen (name);
3153
3154 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3155   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
3156   if (do_obj && len > 2
3157       && name[len - 2] == '.'
3158       && name[len - 1] == 'o')
3159     {
3160       obstack_grow (&obstack, name, len - 2);
3161       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3162       name = XOBFINISH (&obstack, const char *);
3163     }
3164 #endif
3165
3166 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3167   /* If there is no filetype, make it the executable suffix (which includes
3168      the ".").  But don't get confused if we have just "-o".  */
3169   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3170     return name;
3171
3172   for (i = len - 1; i >= 0; i--)
3173     if (IS_DIR_SEPARATOR (name[i]))
3174       break;
3175
3176   for (i++; i < len; i++)
3177     if (name[i] == '.')
3178       return name;
3179
3180   obstack_grow (&obstack, name, len);
3181   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3182                  strlen (TARGET_EXECUTABLE_SUFFIX));
3183   name = XOBFINISH (&obstack, const char *);
3184 #endif
3185
3186   return name;
3187 }
3188 #endif
3189 \f
3190 /* Display the command line switches accepted by gcc.  */
3191 static void
3192 display_help (void)
3193 {
3194   printf (_("Usage: %s [options] file...\n"), programname);
3195   fputs (_("Options:\n"), stdout);
3196
3197   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3198   fputs (_("  --help                   Display this information\n"), stdout);
3199   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3200   if (! verbose_flag)
3201     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3202   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3203   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3204   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3205   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3206   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3207   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3208   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3209   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3210   fputs (_("\
3211   -print-multi-lib         Display the mapping between command line options and\n\
3212                            multiple library search directories\n"), stdout);
3213   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3214   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3215   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3216   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3217   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3218   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3219   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3220   fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3221   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3222   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3223   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3224   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3225   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3226   fputs (_("\
3227   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3228                            and libraries\n"), stdout);
3229   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3230   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3231   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3232   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3233   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3234   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3235   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3236   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3237   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3238   fputs (_("\
3239   -x <language>            Specify the language of the following input files\n\
3240                            Permissible languages include: c c++ assembler none\n\
3241                            'none' means revert to the default behavior of\n\
3242                            guessing the language based on the file's extension\n\
3243 "), stdout);
3244
3245   printf (_("\
3246 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3247  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3248  other options on to these processes the -W<letter> options must be used.\n\
3249 "), programname);
3250
3251   /* The rest of the options are displayed by invocations of the various
3252      sub-processes.  */
3253 }
3254
3255 static void
3256 add_preprocessor_option (const char *option, int len)
3257 {
3258   n_preprocessor_options++;
3259
3260   if (! preprocessor_options)
3261     preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3262   else
3263     preprocessor_options = xrealloc (preprocessor_options,
3264                                      n_preprocessor_options * sizeof (char *));
3265
3266   preprocessor_options [n_preprocessor_options - 1] =
3267     save_string (option, len);
3268 }
3269
3270 static void
3271 add_assembler_option (const char *option, int len)
3272 {
3273   n_assembler_options++;
3274
3275   if (! assembler_options)
3276     assembler_options = XNEWVEC (char *, n_assembler_options);
3277   else
3278     assembler_options = xrealloc (assembler_options,
3279                                   n_assembler_options * sizeof (char *));
3280
3281   assembler_options [n_assembler_options - 1] = save_string (option, len);
3282 }
3283
3284 static void
3285 add_linker_option (const char *option, int len)
3286 {
3287   n_linker_options++;
3288
3289   if (! linker_options)
3290     linker_options = XNEWVEC (char *, n_linker_options);
3291   else
3292     linker_options = xrealloc (linker_options,
3293                                n_linker_options * sizeof (char *));
3294
3295   linker_options [n_linker_options - 1] = save_string (option, len);
3296 }
3297 \f
3298 /* Create the vector `switches' and its contents.
3299    Store its length in `n_switches'.  */
3300
3301 static void
3302 process_command (int argc, const char **argv)
3303 {
3304   int i;
3305   const char *temp;
3306   char *temp1;
3307   const char *spec_lang = 0;
3308   int last_language_n_infiles;
3309   int lang_n_infiles = 0;
3310 #ifdef MODIFY_TARGET_NAME
3311   int is_modify_target_name;
3312   unsigned int j;
3313 #endif
3314
3315   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3316
3317   n_switches = 0;
3318   n_infiles = 0;
3319   added_libraries = 0;
3320
3321   /* Figure compiler version from version string.  */
3322
3323   compiler_version = temp1 = xstrdup (version_string);
3324
3325   for (; *temp1; ++temp1)
3326     {
3327       if (*temp1 == ' ')
3328         {
3329           *temp1 = '\0';
3330           break;
3331         }
3332     }
3333
3334   /* If there is a -V or -b option (or both), process it now, before
3335      trying to interpret the rest of the command line.
3336      Use heuristic that all configuration names must have at least
3337      one dash '-'. This allows us to pass options starting with -b.  */
3338   if (argc > 1 && argv[1][0] == '-'
3339       && (argv[1][1] == 'V' ||
3340          ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
3341     {
3342       const char *new_version = DEFAULT_TARGET_VERSION;
3343       const char *new_machine = DEFAULT_TARGET_MACHINE;
3344       const char *progname = argv[0];
3345       char **new_argv;
3346       char *new_argv0;
3347       int baselen;
3348
3349       while (argc > 1 && argv[1][0] == '-'
3350              && (argv[1][1] == 'V' ||
3351                 ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
3352         {
3353           char opt = argv[1][1];
3354           const char *arg;
3355           if (argv[1][2] != '\0')
3356             {
3357               arg = argv[1] + 2;
3358               argc -= 1;
3359               argv += 1;
3360             }
3361           else if (argc > 2)
3362             {
3363               arg = argv[2];
3364               argc -= 2;
3365               argv += 2;
3366             }
3367           else
3368             fatal ("'-%c' option must have argument", opt);
3369           if (opt == 'V')
3370             new_version = arg;
3371           else
3372             new_machine = arg;
3373         }
3374
3375       for (baselen = strlen (progname); baselen > 0; baselen--)
3376         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3377           break;
3378       new_argv0 = xmemdup (progname, baselen,
3379                            baselen + concat_length (new_version, new_machine,
3380                                                     "-gcc-", NULL) + 1);
3381       strcpy (new_argv0 + baselen, new_machine);
3382       strcat (new_argv0, "-gcc-");
3383       strcat (new_argv0, new_version);
3384
3385       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3386                           (argc + 1) * sizeof (argv[0]));
3387       new_argv[0] = new_argv0;
3388
3389       execvp (new_argv0, new_argv);
3390       fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3391     }
3392
3393   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3394      see if we can create it from the pathname specified in argv[0].  */
3395
3396   gcc_libexec_prefix = standard_libexec_prefix;
3397 #ifndef FREEBSD_NATIVE
3398 #ifndef VMS
3399   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3400   if (!gcc_exec_prefix)
3401     {
3402       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3403                                               standard_exec_prefix);
3404       gcc_libexec_prefix = make_relative_prefix (argv[0],
3405                                                  standard_bindir_prefix,
3406                                                  standard_libexec_prefix);
3407       if (gcc_exec_prefix)
3408         putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3409     }
3410   else
3411     {
3412       /* make_relative_prefix requires a program name, but
3413          GCC_EXEC_PREFIX is typically a directory name with a trailing
3414          / (which is ignored by make_relative_prefix), so append a
3415          program name.  */
3416       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3417       gcc_libexec_prefix = make_relative_prefix (tmp_prefix,
3418                                                  standard_exec_prefix,
3419                                                  standard_libexec_prefix);
3420       free (tmp_prefix);
3421     }
3422 #else
3423 #endif
3424 #endif  /* not FREEBSD_NATIVE */
3425
3426   if (gcc_exec_prefix)
3427     {
3428       int len = strlen (gcc_exec_prefix);
3429
3430       if (len > (int) sizeof ("/lib/gcc/") - 1
3431           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3432         {
3433           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3434           if (IS_DIR_SEPARATOR (*temp)
3435               && strncmp (temp + 1, "lib", 3) == 0
3436               && IS_DIR_SEPARATOR (temp[4])
3437               && strncmp (temp + 5, "gcc", 3) == 0)
3438             len -= sizeof ("/lib/gcc/") - 1;
3439         }
3440
3441       set_std_prefix (gcc_exec_prefix, len);
3442       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3443                   PREFIX_PRIORITY_LAST, 0, 0);
3444       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3445                   PREFIX_PRIORITY_LAST, 0, 0);
3446     }
3447
3448   /* COMPILER_PATH and LIBRARY_PATH have values
3449      that are lists of directory names with colons.  */
3450
3451   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3452   if (temp)
3453     {
3454       const char *startp, *endp;
3455       char *nstore = alloca (strlen (temp) + 3);
3456
3457       startp = endp = temp;
3458       while (1)
3459         {
3460           if (*endp == PATH_SEPARATOR || *endp == 0)
3461             {
3462               strncpy (nstore, startp, endp - startp);
3463               if (endp == startp)
3464                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3465               else if (!IS_DIR_SEPARATOR (endp[-1]))
3466                 {
3467                   nstore[endp - startp] = DIR_SEPARATOR;
3468                   nstore[endp - startp + 1] = 0;
3469                 }
3470               else
3471                 nstore[endp - startp] = 0;
3472               add_prefix (&exec_prefixes, nstore, 0,
3473                           PREFIX_PRIORITY_LAST, 0, 0);
3474               add_prefix (&include_prefixes, nstore, 0,
3475                           PREFIX_PRIORITY_LAST, 0, 0);
3476               if (*endp == 0)
3477                 break;
3478               endp = startp = endp + 1;
3479             }
3480           else
3481             endp++;
3482         }
3483     }
3484
3485   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3486   if (temp && *cross_compile == '0')
3487     {
3488       const char *startp, *endp;
3489       char *nstore = alloca (strlen (temp) + 3);
3490
3491       startp = endp = temp;
3492       while (1)
3493         {
3494           if (*endp == PATH_SEPARATOR || *endp == 0)
3495             {
3496               strncpy (nstore, startp, endp - startp);
3497               if (endp == startp)
3498                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3499               else if (!IS_DIR_SEPARATOR (endp[-1]))
3500                 {
3501                   nstore[endp - startp] = DIR_SEPARATOR;
3502                   nstore[endp - startp + 1] = 0;
3503                 }
3504               else
3505                 nstore[endp - startp] = 0;
3506               add_prefix (&startfile_prefixes, nstore, NULL,
3507                           PREFIX_PRIORITY_LAST, 0, 1);
3508               if (*endp == 0)
3509                 break;
3510               endp = startp = endp + 1;
3511             }
3512           else
3513             endp++;
3514         }
3515     }
3516
3517   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3518   GET_ENVIRONMENT (temp, "LPATH");
3519   if (temp && *cross_compile == '0')
3520     {
3521       const char *startp, *endp;
3522       char *nstore = alloca (strlen (temp) + 3);
3523
3524       startp = endp = temp;
3525       while (1)
3526         {
3527           if (*endp == PATH_SEPARATOR || *endp == 0)
3528             {
3529               strncpy (nstore, startp, endp - startp);
3530               if (endp == startp)
3531                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3532               else if (!IS_DIR_SEPARATOR (endp[-1]))
3533                 {
3534                   nstore[endp - startp] = DIR_SEPARATOR;
3535                   nstore[endp - startp + 1] = 0;
3536                 }
3537               else
3538                 nstore[endp - startp] = 0;
3539               add_prefix (&startfile_prefixes, nstore, NULL,
3540                           PREFIX_PRIORITY_LAST, 0, 1);
3541               if (*endp == 0)
3542                 break;
3543               endp = startp = endp + 1;
3544             }
3545           else
3546             endp++;
3547         }
3548     }
3549
3550   /* Options specified as if they appeared on the command line.  */
3551   temp = getenv ("GCC_OPTIONS");
3552   if ((temp) && (strlen (temp) > 0))
3553     {
3554       int len;
3555       int optc = 1;
3556       int new_argc;
3557       const char **new_argv;
3558       char *envopts;
3559
3560       while (isspace (*temp))
3561         temp++;
3562       len = strlen (temp);
3563       envopts = (char *) xmalloc (len + 1);
3564       strcpy (envopts, temp);
3565
3566       for (i = 0; i < (len - 1); i++)
3567         if ((isspace (envopts[i])) && ! (isspace (envopts[i+1])))
3568           optc++;
3569
3570       new_argv = (const char **) alloca ((optc + argc) * sizeof(char *));
3571
3572       for (i = 0, new_argc = 1; new_argc <= optc; new_argc++)
3573         {
3574           while (isspace (envopts[i]))
3575             i++;
3576           new_argv[new_argc] = envopts + i;
3577           while (!isspace (envopts[i]) && (envopts[i] != '\0'))
3578             i++;
3579           envopts[i++] = '\0';
3580         }
3581       for (i = 1; i < argc; i++)
3582         new_argv[new_argc++] = argv[i];
3583
3584       argv = new_argv;
3585       argc = new_argc;
3586     }
3587
3588   /* Convert new-style -- options to old-style.  */
3589   translate_options (&argc, (const char *const **) &argv);
3590
3591   /* Do language-specific adjustment/addition of flags.  */
3592   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3593
3594   /* Scan argv twice.  Here, the first time, just count how many switches
3595      there will be in their vector, and how many input files in theirs.
3596      Here we also parse the switches that cc itself uses (e.g. -v).  */
3597
3598   for (i = 1; i < argc; i++)
3599     {
3600       if (! strcmp (argv[i], "-dumpspecs"))
3601         {
3602           struct spec_list *sl;
3603           init_spec ();
3604           for (sl = specs; sl; sl = sl->next)
3605             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3606           if (link_command_spec)
3607             printf ("*link_command:\n%s\n\n", link_command_spec);
3608           exit (0);
3609         }
3610       else if (! strcmp (argv[i], "-dumpversion"))
3611         {
3612           printf ("%s\n", spec_version);
3613           exit (0);
3614         }
3615       else if (! strcmp (argv[i], "-dumpmachine"))
3616         {
3617           printf ("%s\n", spec_machine);
3618           exit (0);
3619         }
3620       else if (strcmp (argv[i], "-fversion") == 0)
3621         {
3622           /* translate_options () has turned --version into -fversion.  */
3623           printf (_("%s (GCC) %s\n"), programname, version_string);
3624           printf ("Copyright %s 2007 Free Software Foundation, Inc.\n",
3625                   _("(C)"));
3626           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3627 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3628                  stdout);
3629           exit (0);
3630         }
3631       else if (strcmp (argv[i], "-fhelp") == 0)
3632         {
3633           /* translate_options () has turned --help into -fhelp.  */
3634           print_help_list = 1;
3635
3636           /* We will be passing a dummy file on to the sub-processes.  */
3637           n_infiles++;
3638           n_switches++;
3639
3640           /* CPP driver cannot obtain switch from cc1_options.  */
3641           if (is_cpp_driver)
3642             add_preprocessor_option ("--help", 6);
3643           add_assembler_option ("--help", 6);
3644           add_linker_option ("--help", 6);
3645         }
3646       else if (strcmp (argv[i], "-ftarget-help") == 0)
3647         {
3648           /* translate_options() has turned --target-help into -ftarget-help.  */
3649           target_help_flag = 1;
3650
3651           /* We will be passing a dummy file on to the sub-processes.  */
3652           n_infiles++;
3653           n_switches++;
3654
3655           /* CPP driver cannot obtain switch from cc1_options.  */
3656           if (is_cpp_driver)
3657             add_preprocessor_option ("--target-help", 13);
3658           add_assembler_option ("--target-help", 13);
3659           add_linker_option ("--target-help", 13);
3660         }
3661       else if (! strcmp (argv[i], "-pass-exit-codes"))
3662         {
3663           pass_exit_codes = 1;
3664           n_switches++;
3665         }
3666       else if (! strcmp (argv[i], "-print-search-dirs"))
3667         print_search_dirs = 1;
3668       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3669         print_file_name = "libgcc.a";
3670       else if (! strncmp (argv[i], "-print-file-name=", 17))
3671         print_file_name = argv[i] + 17;
3672       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3673         print_prog_name = argv[i] + 17;
3674       else if (! strcmp (argv[i], "-print-multi-lib"))
3675         print_multi_lib = 1;
3676       else if (! strcmp (argv[i], "-print-multi-directory"))
3677         print_multi_directory = 1;
3678       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3679         print_multi_os_directory = 1;
3680       else if (! strncmp (argv[i], "-Wa,", 4))
3681         {
3682           int prev, j;
3683           /* Pass the rest of this option to the assembler.  */
3684
3685           /* Split the argument at commas.  */
3686           prev = 4;
3687           for (j = 4; argv[i][j]; j++)
3688             if (argv[i][j] == ',')
3689               {
3690                 add_assembler_option (argv[i] + prev, j - prev);
3691                 prev = j + 1;
3692               }
3693
3694           /* Record the part after the last comma.  */
3695           add_assembler_option (argv[i] + prev, j - prev);
3696         }
3697       else if (! strncmp (argv[i], "-Wp,", 4))
3698         {
3699           int prev, j;
3700           /* Pass the rest of this option to the preprocessor.  */
3701
3702           /* Split the argument at commas.  */
3703           prev = 4;
3704           for (j = 4; argv[i][j]; j++)
3705             if (argv[i][j] == ',')
3706               {
3707                 add_preprocessor_option (argv[i] + prev, j - prev);
3708                 prev = j + 1;
3709               }
3710
3711           /* Record the part after the last comma.  */
3712           add_preprocessor_option (argv[i] + prev, j - prev);
3713         }
3714       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3715         /* The +e options to the C++ front-end.  */
3716         n_switches++;
3717       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3718         {
3719           int j;
3720           /* Split the argument at commas.  */
3721           for (j = 3; argv[i][j]; j++)
3722             n_infiles += (argv[i][j] == ',');
3723         }
3724       else if (strcmp (argv[i], "-Xlinker") == 0)
3725         {
3726           if (i + 1 == argc)
3727             fatal ("argument to '-Xlinker' is missing");
3728
3729           n_infiles++;
3730           i++;
3731         }
3732       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3733         {
3734           if (i + 1 == argc)
3735             fatal ("argument to '-Xpreprocessor' is missing");
3736
3737           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3738         }
3739       else if (strcmp (argv[i], "-Xassembler") == 0)
3740         {
3741           if (i + 1 == argc)
3742             fatal ("argument to '-Xassembler' is missing");
3743
3744           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3745         }
3746       else if (strcmp (argv[i], "-l") == 0)
3747         {
3748           if (i + 1 == argc)
3749             fatal ("argument to '-l' is missing");
3750
3751           n_infiles++;
3752           i++;
3753         }
3754       else if (strncmp (argv[i], "-l", 2) == 0)
3755         n_infiles++;
3756       else if (strcmp (argv[i], "-save-temps") == 0)
3757         {
3758           save_temps_flag = 1;
3759           n_switches++;
3760         }
3761       else if (strcmp (argv[i], "-combine") == 0)
3762         {
3763           combine_flag = 1;
3764           n_switches++;
3765         }
3766       else if (strcmp (argv[i], "-specs") == 0)
3767         {
3768           struct user_specs *user = XNEW (struct user_specs);
3769           if (++i >= argc)
3770             fatal ("argument to '-specs' is missing");
3771
3772           user->next = (struct user_specs *) 0;
3773           user->filename = argv[i];
3774           if (user_specs_tail)
3775             user_specs_tail->next = user;
3776           else
3777             user_specs_head = user;
3778           user_specs_tail = user;
3779         }
3780       else if (strncmp (argv[i], "-specs=", 7) == 0)
3781         {
3782           struct user_specs *user = XNEW (struct user_specs);
3783           if (strlen (argv[i]) == 7)
3784             fatal ("argument to '-specs=' is missing");
3785
3786           user->next = (struct user_specs *) 0;
3787           user->filename = argv[i] + 7;
3788           if (user_specs_tail)
3789             user_specs_tail->next = user;
3790           else
3791             user_specs_head = user;
3792           user_specs_tail = user;
3793         }
3794       else if (strcmp (argv[i], "-time") == 0)
3795         report_times = 1;
3796       else if (strcmp (argv[i], "-pipe") == 0)
3797         {
3798           /* -pipe has to go into the switches array as well as
3799              setting a flag.  */
3800           use_pipes = 1;
3801           n_switches++;
3802         }
3803       else if (strcmp (argv[i], "-###") == 0)
3804         {
3805           /* This is similar to -v except that there is no execution
3806              of the commands and the echoed arguments are quoted.  It
3807              is intended for use in shell scripts to capture the
3808              driver-generated command line.  */
3809           verbose_only_flag++;
3810           verbose_flag++;
3811         }
3812       else if (argv[i][0] == '-' && argv[i][1] != 0)
3813         {
3814           const char *p = &argv[i][1];
3815           int c = *p;
3816
3817           switch (c)
3818             {
3819             case 'b':
3820               if (NULL == strchr(argv[i] + 2, '-'))
3821                 goto normal_switch;
3822
3823               /* Fall through.  */
3824             case 'V':
3825               fatal ("'-%c' must come at the start of the command line", c);
3826               break;
3827
3828             case 'B':
3829               {
3830                 const char *value;
3831                 int len;
3832
3833                 if (p[1] == 0 && i + 1 == argc)
3834                   fatal ("argument to '-B' is missing");
3835                 if (p[1] == 0)
3836                   value = argv[++i];
3837                 else
3838                   value = p + 1;
3839
3840                 len = strlen (value);
3841
3842                 /* Catch the case where the user has forgotten to append a
3843                    directory separator to the path.  Note, they may be using
3844                    -B to add an executable name prefix, eg "i386-elf-", in
3845                    order to distinguish between multiple installations of
3846                    GCC in the same directory.  Hence we must check to see
3847                    if appending a directory separator actually makes a
3848                    valid directory name.  */
3849                 if (! IS_DIR_SEPARATOR (value [len - 1])
3850                     && is_directory (value, false))
3851                   {
3852                     char *tmp = XNEWVEC (char, len + 2);
3853                     strcpy (tmp, value);
3854                     tmp[len] = DIR_SEPARATOR;
3855                     tmp[++ len] = 0;
3856                     value = tmp;
3857                   }
3858
3859                 /* As a kludge, if the arg is "[foo/]stageN/", just
3860                    add "[foo/]include" to the include prefix.  */
3861                 if ((len == 7
3862                      || (len > 7
3863                          && (IS_DIR_SEPARATOR (value[len - 8]))))
3864                     && strncmp (value + len - 7, "stage", 5) == 0
3865                     && ISDIGIT (value[len - 2])
3866                     && (IS_DIR_SEPARATOR (value[len - 1])))
3867                   {
3868                     if (len == 7)
3869                       add_prefix (&include_prefixes, "./", NULL,
3870                                   PREFIX_PRIORITY_B_OPT, 0, 0);
3871                     else
3872                       {
3873                         char *string = xmalloc (len - 6);
3874                         memcpy (string, value, len - 7);
3875                         string[len - 7] = 0;
3876                         add_prefix (&include_prefixes, string, NULL,
3877                                     PREFIX_PRIORITY_B_OPT, 0, 0);
3878                       }
3879                   }
3880
3881                 add_prefix (&exec_prefixes, value, NULL,
3882                             PREFIX_PRIORITY_B_OPT, 0, 0);
3883                 add_prefix (&startfile_prefixes, value, NULL,
3884                             PREFIX_PRIORITY_B_OPT, 0, 0);
3885                 add_prefix (&include_prefixes, value, NULL,
3886                             PREFIX_PRIORITY_B_OPT, 0, 0);
3887                 n_switches++;
3888               }
3889               break;
3890
3891             case 'v':   /* Print our subcommands and print versions.  */
3892               n_switches++;
3893               /* If they do anything other than exactly `-v', don't set
3894                  verbose_flag; rather, continue on to give the error.  */
3895               if (p[1] != 0)
3896                 break;
3897               verbose_flag++;
3898               break;
3899
3900             case 'S':
3901             case 'c':
3902               if (p[1] == 0)
3903                 {
3904                   have_c = 1;
3905                   n_switches++;
3906                   break;
3907                 }
3908               goto normal_switch;
3909
3910             case 'o':
3911               have_o = 1;
3912 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3913               if (! have_c)
3914                 {
3915                   int skip;
3916
3917                   /* Forward scan, just in case -S or -c is specified
3918                      after -o.  */
3919                   int j = i + 1;
3920                   if (p[1] == 0)
3921                     ++j;
3922                   while (j < argc)
3923                     {
3924                       if (argv[j][0] == '-')
3925                         {
3926                           if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3927                               && argv[j][2] == 0)
3928                             {
3929                               have_c = 1;
3930                               break;
3931                             }
3932                           else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3933                             j += skip - (argv[j][2] != 0);
3934                           else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3935                             j += skip;
3936                         }
3937                       j++;
3938                     }
3939                 }
3940 #endif
3941 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3942               if (p[1] == 0)
3943                 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3944               else
3945                 argv[i] = convert_filename (argv[i], ! have_c, 0);
3946 #endif
3947               goto normal_switch;
3948
3949             default:
3950             normal_switch:
3951
3952 #ifdef MODIFY_TARGET_NAME
3953               is_modify_target_name = 0;
3954
3955               for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3956                 if (! strcmp (argv[i], modify_target[j].sw))
3957                   {
3958                     char *new_name = xmalloc (strlen (modify_target[j].str)
3959                                               + strlen (spec_machine));
3960                     const char *p, *r;
3961                     char *q;
3962                     int made_addition = 0;
3963
3964                     is_modify_target_name = 1;
3965                     for (p = spec_machine, q = new_name; *p != 0; )
3966                       {
3967                         if (modify_target[j].add_del == DELETE
3968                             && (! strncmp (q, modify_target[j].str,
3969                                            strlen (modify_target[j].str))))
3970                           p += strlen (modify_target[j].str);
3971                         else if (modify_target[j].add_del == ADD
3972                                  && ! made_addition && *p == '-')
3973                           {
3974                             for (r = modify_target[j].str; *r != 0; )
3975                               *q++ = *r++;
3976                             made_addition = 1;
3977                           }
3978
3979                         *q++ = *p++;
3980                       }
3981
3982                     spec_machine = new_name;
3983                   }
3984
3985               if (is_modify_target_name)
3986                 break;
3987 #endif
3988
3989               n_switches++;
3990
3991               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3992                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3993               else if (WORD_SWITCH_TAKES_ARG (p))
3994                 i += WORD_SWITCH_TAKES_ARG (p);
3995             }
3996         }
3997       else
3998         {
3999           n_infiles++;
4000           lang_n_infiles++;
4001         }
4002     }
4003
4004   if (save_temps_flag && use_pipes)
4005     {
4006       /* -save-temps overrides -pipe, so that temp files are produced */
4007       if (save_temps_flag)
4008         error ("warning: -pipe ignored because -save-temps specified");
4009       use_pipes = 0;
4010     }
4011
4012   /* Set up the search paths before we go looking for config files.  */
4013 #ifdef  FREEBSD_NATIVE
4014   add_prefix (&exec_prefixes, PREFIX"/bin/", "BINUTILS",
4015               PREFIX_PRIORITY_LAST, 0, 0);
4016 #endif  /* FREEBSD_NATIVE */
4017
4018   /* These come before the md prefixes so that we will find gcc's subcommands
4019      (such as cpp) rather than those of the host system.  */
4020   /* Use 2 as fourth arg meaning try just the machine as a suffix,
4021      as well as trying the machine and the version.  */
4022 #ifndef OS2
4023   add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4024               PREFIX_PRIORITY_LAST, 1, 0);
4025   add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4026               PREFIX_PRIORITY_LAST, 2, 0);
4027 #ifndef FREEBSD_NATIVE
4028   add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4029               PREFIX_PRIORITY_LAST, 2, 0);
4030   add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
4031               PREFIX_PRIORITY_LAST, 2, 0);
4032   add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
4033               PREFIX_PRIORITY_LAST, 2, 0);
4034 #endif
4035 #endif
4036
4037 #ifndef FREEBSD_NATIVE
4038   add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4039               PREFIX_PRIORITY_LAST, 1, 0);
4040   add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
4041               PREFIX_PRIORITY_LAST, 1, 0);
4042
4043   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4044                            dir_separator_str, NULL);
4045
4046   /* If tooldir is relative, base it on exec_prefixes.  A relative
4047      tooldir lets us move the installed tree as a unit.
4048
4049      If GCC_EXEC_PREFIX is defined, then we want to add two relative
4050      directories, so that we can search both the user specified directory
4051      and the standard place.  */
4052
4053   if (!IS_ABSOLUTE_PATH (tooldir_prefix))
4054     {
4055       if (gcc_exec_prefix)
4056         {
4057           char *gcc_exec_tooldir_prefix
4058             = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
4059                       spec_version, dir_separator_str, tooldir_prefix, NULL);
4060
4061           add_prefix (&exec_prefixes,
4062                       concat (gcc_exec_tooldir_prefix, "bin",
4063                               dir_separator_str, NULL),
4064                       NULL, PREFIX_PRIORITY_LAST, 0, 0);
4065           add_prefix (&startfile_prefixes,
4066                       concat (gcc_exec_tooldir_prefix, "lib",
4067                               dir_separator_str, NULL),
4068                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
4069         }
4070
4071       tooldir_prefix = concat (standard_exec_prefix, spec_machine,
4072                                dir_separator_str, spec_version,
4073                                dir_separator_str, tooldir_prefix, NULL);
4074     }
4075
4076   add_prefix (&exec_prefixes,
4077               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4078               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4079   add_prefix (&startfile_prefixes,
4080               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4081               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4082
4083 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4084   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4085      then consider it to relocate with the rest of the GCC installation
4086      if GCC_EXEC_PREFIX is set.
4087      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
4088   if (target_system_root && gcc_exec_prefix)
4089     {
4090       char *tmp_prefix = make_relative_prefix (argv[0],
4091                                                standard_bindir_prefix,
4092                                                target_system_root);
4093       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4094         {
4095           target_system_root = tmp_prefix;
4096           target_system_root_changed = 1;
4097         }
4098     }
4099 #endif
4100 #endif /* FREEBSD_NATIVE */
4101
4102   /* More prefixes are enabled in main, after we read the specs file
4103      and determine whether this is cross-compilation or not.  */
4104
4105   /* Then create the space for the vectors and scan again.  */
4106
4107   switches = XNEWVEC (struct switchstr, n_switches + 1);
4108   infiles = XNEWVEC (struct infile, n_infiles + 1);
4109   n_switches = 0;
4110   n_infiles = 0;
4111   last_language_n_infiles = -1;
4112
4113   /* This, time, copy the text of each switch and store a pointer
4114      to the copy in the vector of switches.
4115      Store all the infiles in their vector.  */
4116
4117   for (i = 1; i < argc; i++)
4118     {
4119       /* Just skip the switches that were handled by the preceding loop.  */
4120 #ifdef MODIFY_TARGET_NAME
4121       is_modify_target_name = 0;
4122
4123       for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4124         if (! strcmp (argv[i], modify_target[j].sw))
4125           is_modify_target_name = 1;
4126
4127       if (is_modify_target_name)
4128         ;
4129       else
4130 #endif
4131       if (! strncmp (argv[i], "-Wa,", 4))
4132         ;
4133       else if (! strncmp (argv[i], "-Wp,", 4))
4134         ;
4135       else if (! strcmp (argv[i], "-pass-exit-codes"))
4136         ;
4137       else if (! strcmp (argv[i], "-print-search-dirs"))
4138         ;
4139       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4140         ;
4141       else if (! strncmp (argv[i], "-print-file-name=", 17))
4142         ;
4143       else if (! strncmp (argv[i], "-print-prog-name=", 17))
4144         ;
4145       else if (! strcmp (argv[i], "-print-multi-lib"))
4146         ;
4147       else if (! strcmp (argv[i], "-print-multi-directory"))
4148         ;
4149       else if (! strcmp (argv[i], "-print-multi-os-directory"))
4150         ;
4151       else if (! strcmp (argv[i], "-ftarget-help"))
4152         ;
4153       else if (! strcmp (argv[i], "-fhelp"))
4154         ;
4155       else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4156         {
4157           target_system_root = argv[i] + strlen ("--sysroot=");
4158           target_system_root_changed = 1;
4159         }
4160       else if (argv[i][0] == '+' && argv[i][1] == 'e')
4161         {
4162           /* Compensate for the +e options to the C++ front-end;
4163              they're there simply for cfront call-compatibility.  We do
4164              some magic in default_compilers to pass them down properly.
4165              Note we deliberately start at the `+' here, to avoid passing
4166              -e0 or -e1 down into the linker.  */
4167           switches[n_switches].part1 = &argv[i][0];
4168           switches[n_switches].args = 0;
4169           switches[n_switches].live_cond = SWITCH_OK;
4170           switches[n_switches].validated = 0;
4171           n_switches++;
4172         }
4173       else if (strncmp (argv[i], "-Wl,", 4) == 0)
4174         {
4175           int prev, j;
4176           /* Split the argument at commas.  */
4177           prev = 4;
4178           for (j = 4; argv[i][j]; j++)
4179             if (argv[i][j] == ',')
4180               {
4181                 infiles[n_infiles].language = "*";
4182                 infiles[n_infiles++].name
4183                   = save_string (argv[i] + prev, j - prev);
4184                 prev = j + 1;
4185               }
4186           /* Record the part after the last comma.  */
4187           infiles[n_infiles].language = "*";
4188           infiles[n_infiles++].name = argv[i] + prev;
4189         }
4190       else if (strcmp (argv[i], "-Xlinker") == 0)
4191         {
4192           infiles[n_infiles].language = "*";
4193           infiles[n_infiles++].name = argv[++i];
4194         }
4195       /* Xassembler and Xpreprocessor were already handled in the first argv
4196          scan, so all we need to do here is ignore them and their argument.  */
4197       else if (strcmp (argv[i], "-Xassembler") == 0)
4198         i++;
4199       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4200         i++;
4201       else if (strcmp (argv[i], "-l") == 0)
4202         { /* POSIX allows separation of -l and the lib arg;
4203              canonicalize by concatenating -l with its arg */
4204           infiles[n_infiles].language = "*";
4205           infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4206         }
4207       else if (strncmp (argv[i], "-l", 2) == 0)
4208         {
4209           infiles[n_infiles].language = "*";
4210           infiles[n_infiles++].name = argv[i];
4211         }
4212       else if (strcmp (argv[i], "-specs") == 0)
4213         i++;
4214       else if (strncmp (argv[i], "-specs=", 7) == 0)
4215         ;
4216       else if (strcmp (argv[i], "-time") == 0)
4217         ;
4218       else if (strcmp (argv[i], "-###") == 0)
4219         ;
4220       else if (argv[i][0] == '-' && argv[i][1] != 0)
4221         {
4222           const char *p = &argv[i][1];
4223           int c = *p;
4224
4225           if (c == 'x')
4226             {
4227               if (p[1] == 0 && i + 1 == argc)
4228                 fatal ("argument to '-x' is missing");
4229               if (p[1] == 0)
4230                 spec_lang = argv[++i];
4231               else
4232                 spec_lang = p + 1;
4233               if (! strcmp (spec_lang, "none"))
4234                 /* Suppress the warning if -xnone comes after the last input
4235                    file, because alternate command interfaces like g++ might
4236                    find it useful to place -xnone after each input file.  */
4237                 spec_lang = 0;
4238               else
4239                 last_language_n_infiles = n_infiles;
4240               continue;
4241             }
4242           switches[n_switches].part1 = p;
4243           /* Deal with option arguments in separate argv elements.  */
4244           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4245               || WORD_SWITCH_TAKES_ARG (p))
4246             {
4247               int j = 0;
4248               int n_args = WORD_SWITCH_TAKES_ARG (p);
4249
4250               if (n_args == 0)
4251                 {
4252                   /* Count only the option arguments in separate argv elements.  */
4253                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4254                 }
4255               if (i + n_args >= argc)
4256                 fatal ("argument to '-%s' is missing", p);
4257               switches[n_switches].args
4258                 = XNEWVEC (const char *, n_args + 1);
4259               while (j < n_args)
4260                 switches[n_switches].args[j++] = argv[++i];
4261               /* Null-terminate the vector.  */
4262               switches[n_switches].args[j] = 0;
4263             }
4264           else if (strchr (switches_need_spaces, c))
4265             {
4266               /* On some systems, ld cannot handle some options without
4267                  a space.  So split the option from its argument.  */
4268               char *part1 = XNEWVEC (char, 2);
4269               part1[0] = c;
4270               part1[1] = '\0';
4271
4272               switches[n_switches].part1 = part1;
4273               switches[n_switches].args = XNEWVEC (const char *, 2);
4274               switches[n_switches].args[0] = xstrdup (p+1);
4275               switches[n_switches].args[1] = 0;
4276             }
4277           else
4278             switches[n_switches].args = 0;
4279
4280           switches[n_switches].live_cond = SWITCH_OK;
4281           switches[n_switches].validated = 0;
4282           switches[n_switches].ordering = 0;
4283           /* These are always valid, since gcc.c itself understands them.  */
4284           if (!strcmp (p, "save-temps")
4285               || !strcmp (p, "static-libgcc")
4286               || !strcmp (p, "shared-libgcc")
4287               || !strcmp (p, "pipe"))
4288             switches[n_switches].validated = 1;
4289           else
4290             {
4291               char ch = switches[n_switches].part1[0];
4292               if (ch == 'B')
4293                 switches[n_switches].validated = 1;
4294             }
4295           n_switches++;
4296         }
4297       else
4298         {
4299 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4300           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4301 #endif
4302
4303           if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4304             {
4305               perror_with_name (argv[i]);
4306               error_count++;
4307             }
4308           else
4309             {
4310               infiles[n_infiles].language = spec_lang;
4311               infiles[n_infiles++].name = argv[i];
4312             }
4313         }
4314     }
4315
4316   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4317     error ("warning: '-x %s' after last input file has no effect", spec_lang);
4318
4319   /* Ensure we only invoke each subprocess once.  */
4320   if (target_help_flag || print_help_list)
4321     {
4322       n_infiles = 1;
4323
4324       /* Create a dummy input file, so that we can pass --target-help on to
4325          the various sub-processes.  */
4326       infiles[0].language = "c";
4327       infiles[0].name   = "help-dummy";
4328
4329       if (target_help_flag)
4330         {
4331           switches[n_switches].part1     = "--target-help";
4332           switches[n_switches].args      = 0;
4333           switches[n_switches].live_cond = SWITCH_OK;
4334           switches[n_switches].validated = 0;
4335
4336           n_switches++;
4337         }
4338
4339       if (print_help_list)
4340         {
4341           switches[n_switches].part1     = "--help";
4342           switches[n_switches].args      = 0;
4343           switches[n_switches].live_cond = SWITCH_OK;
4344           switches[n_switches].validated = 0;
4345
4346           n_switches++;
4347         }
4348     }
4349
4350   switches[n_switches].part1 = 0;
4351   infiles[n_infiles].name = 0;
4352 }
4353
4354 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4355    and place that in the environment.  */
4356
4357 static void
4358 set_collect_gcc_options (void)
4359 {
4360   int i;
4361   int first_time;
4362
4363   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4364      the compiler.  */
4365   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4366                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4367
4368   first_time = TRUE;
4369   for (i = 0; (int) i < n_switches; i++)
4370     {
4371       const char *const *args;
4372       const char *p, *q;
4373       if (!first_time)
4374         obstack_grow (&collect_obstack, " ", 1);
4375
4376       first_time = FALSE;
4377
4378       /* Ignore elided switches.  */
4379       if (switches[i].live_cond == SWITCH_IGNORE)
4380         continue;
4381
4382       obstack_grow (&collect_obstack, "'-", 2);
4383       q = switches[i].part1;
4384       while ((p = strchr (q, '\'')))
4385         {
4386           obstack_grow (&collect_obstack, q, p - q);
4387           obstack_grow (&collect_obstack, "'\\''", 4);
4388           q = ++p;
4389         }
4390       obstack_grow (&collect_obstack, q, strlen (q));
4391       obstack_grow (&collect_obstack, "'", 1);
4392
4393       for (args = switches[i].args; args && *args; args++)
4394         {
4395           obstack_grow (&collect_obstack, " '", 2);
4396           q = *args;
4397           while ((p = strchr (q, '\'')))
4398             {
4399               obstack_grow (&collect_obstack, q, p - q);
4400               obstack_grow (&collect_obstack, "'\\''", 4);
4401               q = ++p;
4402             }
4403           obstack_grow (&collect_obstack, q, strlen (q));
4404           obstack_grow (&collect_obstack, "'", 1);
4405         }
4406     }
4407   obstack_grow (&collect_obstack, "\0", 1);
4408   putenv (XOBFINISH (&collect_obstack, char *));
4409 }
4410 \f
4411 /* Process a spec string, accumulating and running commands.  */
4412
4413 /* These variables describe the input file name.
4414    input_file_number is the index on outfiles of this file,
4415    so that the output file name can be stored for later use by %o.
4416    input_basename is the start of the part of the input file
4417    sans all directory names, and basename_length is the number
4418    of characters starting there excluding the suffix .c or whatever.  */
4419
4420 static const char *input_filename;
4421 static int input_file_number;
4422 size_t input_filename_length;
4423 static int basename_length;
4424 static int suffixed_basename_length;
4425 static const char *input_basename;
4426 static const char *input_suffix;
4427 #ifndef HOST_LACKS_INODE_NUMBERS
4428 static struct stat input_stat;
4429 #endif
4430 static int input_stat_set;
4431
4432 /* The compiler used to process the current input file.  */
4433 static struct compiler *input_file_compiler;
4434
4435 /* These are variables used within do_spec and do_spec_1.  */
4436
4437 /* Nonzero if an arg has been started and not yet terminated
4438    (with space, tab or newline).  */
4439 static int arg_going;
4440
4441 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4442    is a temporary file name.  */
4443 static int delete_this_arg;
4444
4445 /* Nonzero means %w has been seen; the next arg to be terminated
4446    is the output file name of this compilation.  */
4447 static int this_is_output_file;
4448
4449 /* Nonzero means %s has been seen; the next arg to be terminated
4450    is the name of a library file and we should try the standard
4451    search dirs for it.  */
4452 static int this_is_library_file;
4453
4454 /* Nonzero means that the input of this command is coming from a pipe.  */
4455 static int input_from_pipe;
4456
4457 /* Nonnull means substitute this for any suffix when outputting a switches
4458    arguments.  */
4459 static const char *suffix_subst;
4460
4461 /* Process the spec SPEC and run the commands specified therein.
4462    Returns 0 if the spec is successfully processed; -1 if failed.  */
4463
4464 int
4465 do_spec (const char *spec)
4466 {
4467   int value;
4468
4469   value = do_spec_2 (spec);
4470
4471   /* Force out any unfinished command.
4472      If -pipe, this forces out the last command if it ended in `|'.  */
4473   if (value == 0)
4474     {
4475       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4476         argbuf_index--;
4477
4478       set_collect_gcc_options ();
4479
4480       if (argbuf_index > 0)
4481         value = execute ();
4482     }
4483
4484   return value;
4485 }
4486
4487 static int
4488 do_spec_2 (const char *spec)
4489 {
4490   const char *string;
4491   int result;
4492
4493   clear_args ();
4494   arg_going = 0;
4495   delete_this_arg = 0;
4496   this_is_output_file = 0;
4497   this_is_library_file = 0;
4498   input_from_pipe = 0;
4499   suffix_subst = NULL;
4500
4501   result = do_spec_1 (spec, 0, NULL);
4502
4503   /* End any pending argument.  */
4504   if (arg_going)
4505     {
4506       obstack_1grow (&obstack, 0);
4507       string = XOBFINISH (&obstack, const char *);
4508       if (this_is_library_file)
4509         string = find_file (string);
4510       store_arg (string, delete_this_arg, this_is_output_file);
4511       if (this_is_output_file)
4512         outfiles[input_file_number] = string;
4513       arg_going = 0;
4514     }
4515
4516   return result;
4517 }
4518
4519
4520 /* Process the given spec string and add any new options to the end
4521    of the switches/n_switches array.  */
4522
4523 static void
4524 do_option_spec (const char *name, const char *spec)
4525 {
4526   unsigned int i, value_count, value_len;
4527   const char *p, *q, *value;
4528   char *tmp_spec, *tmp_spec_p;
4529
4530   if (configure_default_options[0].name == NULL)
4531     return;
4532
4533   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4534     if (strcmp (configure_default_options[i].name, name) == 0)
4535       break;
4536   if (i == ARRAY_SIZE (configure_default_options))
4537     return;
4538
4539   value = configure_default_options[i].value;
4540   value_len = strlen (value);
4541
4542   /* Compute the size of the final spec.  */
4543   value_count = 0;
4544   p = spec;
4545   while ((p = strstr (p, "%(VALUE)")) != NULL)
4546     {
4547       p ++;
4548       value_count ++;
4549     }
4550
4551   /* Replace each %(VALUE) by the specified value.  */
4552   tmp_spec = alloca (strlen (spec) + 1
4553                      + value_count * (value_len - strlen ("%(VALUE)")));
4554   tmp_spec_p = tmp_spec;
4555   q = spec;
4556   while ((p = strstr (q, "%(VALUE)")) != NULL)
4557     {
4558       memcpy (tmp_spec_p, q, p - q);
4559       tmp_spec_p = tmp_spec_p + (p - q);
4560       memcpy (tmp_spec_p, value, value_len);
4561       tmp_spec_p += value_len;
4562       q = p + strlen ("%(VALUE)");
4563     }
4564   strcpy (tmp_spec_p, q);
4565
4566   do_self_spec (tmp_spec);
4567 }
4568
4569 /* Process the given spec string and add any new options to the end
4570    of the switches/n_switches array.  */
4571
4572 static void
4573 do_self_spec (const char *spec)
4574 {
4575   do_spec_2 (spec);
4576   do_spec_1 (" ", 0, NULL);
4577
4578   if (argbuf_index > 0)
4579     {
4580       int i, first;
4581
4582       first = n_switches;
4583       n_switches += argbuf_index;
4584       switches = xrealloc (switches,
4585                            sizeof (struct switchstr) * (n_switches + 1));
4586
4587       switches[n_switches] = switches[first];
4588       for (i = 0; i < argbuf_index; i++)
4589         {
4590           struct switchstr *sw;
4591
4592           /* Each switch should start with '-'.  */
4593           if (argbuf[i][0] != '-')
4594             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4595
4596           sw = &switches[i + first];
4597           sw->part1 = &argbuf[i][1];
4598           sw->args = 0;
4599           sw->live_cond = SWITCH_OK;
4600           sw->validated = 0;
4601           sw->ordering = 0;
4602         }
4603     }
4604 }
4605
4606 /* Callback for processing %D and %I specs.  */
4607
4608 struct spec_path_info {
4609   const char *option;
4610   const char *append;
4611   size_t append_len;
4612   bool omit_relative;
4613   bool separate_options;
4614 };
4615
4616 static void *
4617 spec_path (char *path, void *data)
4618 {
4619   struct spec_path_info *info = data;
4620   size_t len = 0;
4621   char save = 0;
4622
4623   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4624     return NULL;
4625
4626   if (info->append_len != 0)
4627     {
4628       len = strlen (path);
4629       memcpy (path + len, info->append, info->append_len + 1);
4630     }
4631
4632   if (!is_directory (path, true))
4633     return NULL;
4634
4635   do_spec_1 (info->option, 1, NULL);
4636   if (info->separate_options)
4637     do_spec_1 (" ", 0, NULL);
4638
4639   if (info->append_len == 0)
4640     {
4641       len = strlen (path);
4642       save = path[len - 1];
4643       if (IS_DIR_SEPARATOR (path[len - 1]))
4644         path[len - 1] = '\0';
4645     }
4646
4647   do_spec_1 (path, 1, NULL);
4648   do_spec_1 (" ", 0, NULL);
4649
4650   /* Must not damage the original path.  */
4651   if (info->append_len == 0)
4652     path[len - 1] = save;
4653
4654   return NULL;
4655 }
4656
4657 /* Process the sub-spec SPEC as a portion of a larger spec.
4658    This is like processing a whole spec except that we do
4659    not initialize at the beginning and we do not supply a
4660    newline by default at the end.
4661    INSWITCH nonzero means don't process %-sequences in SPEC;
4662    in this case, % is treated as an ordinary character.
4663    This is used while substituting switches.
4664    INSWITCH nonzero also causes SPC not to terminate an argument.
4665
4666    Value is zero unless a line was finished
4667    and the command on that line reported an error.  */
4668
4669 static int
4670 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4671 {
4672   const char *p = spec;
4673   int c;
4674   int i;
4675   const char *string;
4676   int value;
4677
4678   while ((c = *p++))
4679     /* If substituting a switch, treat all chars like letters.
4680        Otherwise, NL, SPC, TAB and % are special.  */
4681     switch (inswitch ? 'a' : c)
4682       {
4683       case '\n':
4684         /* End of line: finish any pending argument,
4685            then run the pending command if one has been started.  */
4686         if (arg_going)
4687           {
4688             obstack_1grow (&obstack, 0);
4689             string = XOBFINISH (&obstack, const char *);
4690             if (this_is_library_file)
4691               string = find_file (string);
4692             store_arg (string, delete_this_arg, this_is_output_file);
4693             if (this_is_output_file)
4694               outfiles[input_file_number] = string;
4695           }
4696         arg_going = 0;
4697
4698         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4699           {
4700             /* A `|' before the newline means use a pipe here,
4701                but only if -pipe was specified.
4702                Otherwise, execute now and don't pass the `|' as an arg.  */
4703             if (use_pipes)
4704               {
4705                 input_from_pipe = 1;
4706                 break;
4707               }
4708             else
4709               argbuf_index--;
4710           }
4711
4712         set_collect_gcc_options ();
4713
4714         if (argbuf_index > 0)
4715           {
4716             value = execute ();
4717             if (value)
4718               return value;
4719           }
4720         /* Reinitialize for a new command, and for a new argument.  */
4721         clear_args ();
4722         arg_going = 0;
4723         delete_this_arg = 0;
4724         this_is_output_file = 0;
4725         this_is_library_file = 0;
4726         input_from_pipe = 0;
4727         break;
4728
4729       case '|':
4730         /* End any pending argument.  */
4731         if (arg_going)
4732           {
4733             obstack_1grow (&obstack, 0);
4734             string = XOBFINISH (&obstack, const char *);
4735             if (this_is_library_file)
4736               string = find_file (string);
4737             store_arg (string, delete_this_arg, this_is_output_file);
4738             if (this_is_output_file)
4739               outfiles[input_file_number] = string;
4740           }
4741
4742         /* Use pipe */
4743         obstack_1grow (&obstack, c);
4744         arg_going = 1;
4745         break;
4746
4747       case '\t':
4748       case ' ':
4749         /* Space or tab ends an argument if one is pending.  */
4750         if (arg_going)
4751           {
4752             obstack_1grow (&obstack, 0);
4753             string = XOBFINISH (&obstack, const char *);
4754             if (this_is_library_file)
4755               string = find_file (string);
4756             store_arg (string, delete_this_arg, this_is_output_file);
4757             if (this_is_output_file)
4758               outfiles[input_file_number] = string;
4759           }
4760         /* Reinitialize for a new argument.  */
4761         arg_going = 0;
4762         delete_this_arg = 0;
4763         this_is_output_file = 0;
4764         this_is_library_file = 0;
4765         break;
4766
4767       case '%':
4768         switch (c = *p++)
4769           {
4770           case 0:
4771             fatal ("spec '%s' invalid", spec);
4772
4773           case 'b':
4774             obstack_grow (&obstack, input_basename, basename_length);
4775             arg_going = 1;
4776             break;
4777
4778           case 'B':
4779             obstack_grow (&obstack, input_basename, suffixed_basename_length);
4780             arg_going = 1;
4781             break;
4782
4783           case 'd':
4784             delete_this_arg = 2;
4785             break;
4786
4787           /* Dump out the directories specified with LIBRARY_PATH,
4788              followed by the absolute directories
4789              that we search for startfiles.  */
4790           case 'D':
4791             {
4792               struct spec_path_info info;
4793
4794               info.option = "-L";
4795               info.append_len = 0;
4796 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4797               /* Used on systems which record the specified -L dirs
4798                  and use them to search for dynamic linking.
4799                  Relative directories always come from -B,
4800                  and it is better not to use them for searching
4801                  at run time.  In particular, stage1 loses.  */
4802               info.omit_relative = true;
4803 #else
4804               info.omit_relative = false;
4805 #endif
4806               info.separate_options = false;
4807
4808               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4809             }
4810             break;
4811
4812           case 'e':
4813             /* %efoo means report an error with `foo' as error message
4814                and don't execute any more commands for this file.  */
4815             {
4816               const char *q = p;
4817               char *buf;
4818               while (*p != 0 && *p != '\n')
4819                 p++;
4820               buf = alloca (p - q + 1);
4821               strncpy (buf, q, p - q);
4822               buf[p - q] = 0;
4823               error ("%s", buf);
4824               return -1;
4825             }
4826             break;
4827           case 'n':
4828             /* %nfoo means report a notice with `foo' on stderr.  */
4829             {
4830               const char *q = p;
4831               char *buf;
4832               while (*p != 0 && *p != '\n')
4833                 p++;
4834               buf = alloca (p - q + 1);
4835               strncpy (buf, q, p - q);
4836               buf[p - q] = 0;
4837               notice ("%s\n", buf);
4838               if (*p)
4839                 p++;
4840             }
4841             break;
4842
4843           case 'j':
4844             {
4845               struct stat st;
4846
4847               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4848                  defined, and it is not a directory, and it is
4849                  writable, use it.  Otherwise, treat this like any
4850                  other temporary file.  */
4851
4852               if ((!save_temps_flag)
4853                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4854                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4855                 {
4856                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4857                                 strlen (HOST_BIT_BUCKET));
4858                   delete_this_arg = 0;
4859                   arg_going = 1;
4860                   break;
4861                 }
4862             }
4863             goto create_temp_file;
4864           case '|':
4865             if (use_pipes)
4866               {
4867                 obstack_1grow (&obstack, '-');
4868                 delete_this_arg = 0;
4869                 arg_going = 1;
4870
4871                 /* consume suffix */
4872                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4873                   p++;
4874                 if (p[0] == '%' && p[1] == 'O')
4875                   p += 2;
4876
4877                 break;
4878               }
4879             goto create_temp_file;
4880           case 'm':
4881             if (use_pipes)
4882               {
4883                 /* consume suffix */
4884                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4885                   p++;
4886                 if (p[0] == '%' && p[1] == 'O')
4887                   p += 2;
4888
4889                 break;
4890               }
4891             goto create_temp_file;
4892           case 'g':
4893           case 'u':
4894           case 'U':
4895           create_temp_file:
4896               {
4897                 struct temp_name *t;
4898                 int suffix_length;
4899                 const char *suffix = p;
4900                 char *saved_suffix = NULL;
4901
4902                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4903                   p++;
4904                 suffix_length = p - suffix;
4905                 if (p[0] == '%' && p[1] == 'O')
4906                   {
4907                     p += 2;
4908                     /* We don't support extra suffix characters after %O.  */
4909                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4910                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
4911                     if (suffix_length == 0)
4912                       suffix = TARGET_OBJECT_SUFFIX;
4913                     else
4914                       {
4915                         saved_suffix
4916                           = XNEWVEC (char, suffix_length
4917                                      + strlen (TARGET_OBJECT_SUFFIX));
4918                         strncpy (saved_suffix, suffix, suffix_length);
4919                         strcpy (saved_suffix + suffix_length,
4920                                 TARGET_OBJECT_SUFFIX);
4921                       }
4922                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4923                   }
4924
4925                 /* If the input_filename has the same suffix specified
4926                    for the %g, %u, or %U, and -save-temps is specified,
4927                    we could end up using that file as an intermediate
4928                    thus clobbering the user's source file (.e.g.,
4929                    gcc -save-temps foo.s would clobber foo.s with the
4930                    output of cpp0).  So check for this condition and
4931                    generate a temp file as the intermediate.  */
4932
4933                 if (save_temps_flag)
4934                   {
4935                     temp_filename_length = basename_length + suffix_length;
4936                     temp_filename = alloca (temp_filename_length + 1);
4937                     strncpy ((char *) temp_filename, input_basename, basename_length);
4938                     strncpy ((char *) temp_filename + basename_length, suffix,
4939                              suffix_length);
4940                     *((char *) temp_filename + temp_filename_length) = '\0';
4941                     if (strcmp (temp_filename, input_filename) != 0)
4942                       {
4943 #ifndef HOST_LACKS_INODE_NUMBERS
4944                         struct stat st_temp;
4945
4946                         /* Note, set_input() resets input_stat_set to 0.  */
4947                         if (input_stat_set == 0)
4948                           {
4949                             input_stat_set = stat (input_filename, &input_stat);
4950                             if (input_stat_set >= 0)
4951                               input_stat_set = 1;
4952                           }
4953
4954                         /* If we have the stat for the input_filename
4955                            and we can do the stat for the temp_filename
4956                            then the they could still refer to the same
4957                            file if st_dev/st_ino's are the same.  */
4958                         if (input_stat_set != 1
4959                             || stat (temp_filename, &st_temp) < 0
4960                             || input_stat.st_dev != st_temp.st_dev
4961                             || input_stat.st_ino != st_temp.st_ino)
4962 #else
4963                         /* Just compare canonical pathnames.  */
4964                         char* input_realname = lrealpath (input_filename);
4965                         char* temp_realname = lrealpath (temp_filename);
4966                         bool files_differ = strcmp (input_realname, temp_realname);
4967                         free (input_realname);
4968                         free (temp_realname);
4969                         if (files_differ)
4970 #endif
4971                           {
4972                             temp_filename = save_string (temp_filename,
4973                                                          temp_filename_length + 1);
4974                             obstack_grow (&obstack, temp_filename,
4975                                                     temp_filename_length);
4976                             arg_going = 1;
4977                             delete_this_arg = 0;
4978                             break;
4979                           }
4980                       }
4981                   }
4982
4983                 /* See if we already have an association of %g/%u/%U and
4984                    suffix.  */
4985                 for (t = temp_names; t; t = t->next)
4986                   if (t->length == suffix_length
4987                       && strncmp (t->suffix, suffix, suffix_length) == 0
4988                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4989                     break;
4990
4991                 /* Make a new association if needed.  %u and %j
4992                    require one.  */
4993                 if (t == 0 || c == 'u' || c == 'j')
4994                   {
4995                     if (t == 0)
4996                       {
4997                         t = xmalloc (sizeof (struct temp_name));
4998                         t->next = temp_names;
4999                         temp_names = t;
5000                       }
5001                     t->length = suffix_length;
5002                     if (saved_suffix)
5003                       {
5004                         t->suffix = saved_suffix;
5005                         saved_suffix = NULL;
5006                       }
5007                     else
5008                       t->suffix = save_string (suffix, suffix_length);
5009                     t->unique = (c == 'u' || c == 'U' || c == 'j');
5010                     temp_filename = make_temp_file (t->suffix);
5011                     temp_filename_length = strlen (temp_filename);
5012                     t->filename = temp_filename;
5013                     t->filename_length = temp_filename_length;
5014                   }
5015
5016                 if (saved_suffix)
5017                   free (saved_suffix);
5018
5019                 obstack_grow (&obstack, t->filename, t->filename_length);
5020                 delete_this_arg = 1;
5021               }
5022             arg_going = 1;
5023             break;
5024
5025           case 'i':
5026             if (combine_inputs)
5027               {
5028                 for (i = 0; (int) i < n_infiles; i++)
5029                   if ((!infiles[i].language) || (infiles[i].language[0] != '*'))
5030                     if (infiles[i].incompiler == input_file_compiler)
5031                       {
5032                         store_arg (infiles[i].name, 0, 0);
5033                         infiles[i].compiled = true;
5034                       }
5035               }
5036             else
5037               {
5038                 obstack_grow (&obstack, input_filename, input_filename_length);
5039                 arg_going = 1;
5040               }
5041             break;
5042
5043           case 'I':
5044             {
5045               struct spec_path_info info;
5046
5047               if (multilib_dir)
5048                 {
5049                   do_spec_1 ("-imultilib", 1, NULL);
5050                   /* Make this a separate argument.  */
5051                   do_spec_1 (" ", 0, NULL);
5052                   do_spec_1 (multilib_dir, 1, NULL);
5053                   do_spec_1 (" ", 0, NULL);
5054                 }
5055
5056               if (gcc_exec_prefix)
5057                 {
5058                   do_spec_1 ("-iprefix", 1, NULL);
5059                   /* Make this a separate argument.  */
5060                   do_spec_1 (" ", 0, NULL);
5061                   do_spec_1 (gcc_exec_prefix, 1, NULL);
5062                   do_spec_1 (" ", 0, NULL);
5063                 }
5064
5065               if (target_system_root_changed ||
5066                   (target_system_root && target_sysroot_hdrs_suffix))
5067                 {
5068                   do_spec_1 ("-isysroot", 1, NULL);
5069                   /* Make this a separate argument.  */
5070                   do_spec_1 (" ", 0, NULL);
5071                   do_spec_1 (target_system_root, 1, NULL);
5072                   if (target_sysroot_hdrs_suffix)
5073                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5074                   do_spec_1 (" ", 0, NULL);
5075                 }
5076
5077               info.option = "-isystem";
5078               info.append = "include";
5079               info.append_len = strlen (info.append);
5080               info.omit_relative = false;
5081               info.separate_options = true;
5082
5083               for_each_path (&include_prefixes, false, info.append_len,
5084                              spec_path, &info);
5085             }
5086             break;
5087
5088           case 'o':
5089             {
5090               int max = n_infiles;
5091               max += lang_specific_extra_outfiles;
5092
5093               for (i = 0; i < max; i++)
5094                 if (outfiles[i])
5095                   store_arg (outfiles[i], 0, 0);
5096               break;
5097             }
5098
5099           case 'O':
5100             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5101             arg_going = 1;
5102             break;
5103
5104           case 's':
5105             this_is_library_file = 1;
5106             break;
5107
5108           case 'V':
5109             outfiles[input_file_number] = NULL;
5110             break;
5111
5112           case 'w':
5113             this_is_output_file = 1;
5114             break;
5115
5116           case 'W':
5117             {
5118               int cur_index = argbuf_index;
5119               /* Handle the {...} following the %W.  */
5120               if (*p != '{')
5121                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5122               p = handle_braces (p + 1);
5123               if (p == 0)
5124                 return -1;
5125               /* End any pending argument.  */
5126               if (arg_going)
5127                 {
5128                   obstack_1grow (&obstack, 0);
5129                   string = XOBFINISH (&obstack, const char *);
5130                   if (this_is_library_file)
5131                     string = find_file (string);
5132                   store_arg (string, delete_this_arg, this_is_output_file);
5133                   if (this_is_output_file)
5134                     outfiles[input_file_number] = string;
5135                   arg_going = 0;
5136                 }
5137               /* If any args were output, mark the last one for deletion
5138                  on failure.  */
5139               if (argbuf_index != cur_index)
5140                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5141               break;
5142             }
5143
5144           /* %x{OPTION} records OPTION for %X to output.  */
5145           case 'x':
5146             {
5147               const char *p1 = p;
5148               char *string;
5149
5150               /* Skip past the option value and make a copy.  */
5151               if (*p != '{')
5152                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5153               while (*p++ != '}')
5154                 ;
5155               string = save_string (p1 + 1, p - p1 - 2);
5156
5157               /* See if we already recorded this option.  */
5158               for (i = 0; i < n_linker_options; i++)
5159                 if (! strcmp (string, linker_options[i]))
5160                   {
5161                     free (string);
5162                     return 0;
5163                   }
5164
5165               /* This option is new; add it.  */
5166               add_linker_option (string, strlen (string));
5167             }
5168             break;
5169
5170           /* Dump out the options accumulated previously using %x.  */
5171           case 'X':
5172             for (i = 0; i < n_linker_options; i++)
5173               {
5174                 do_spec_1 (linker_options[i], 1, NULL);
5175                 /* Make each accumulated option a separate argument.  */
5176                 do_spec_1 (" ", 0, NULL);
5177               }
5178             break;
5179
5180           /* Dump out the options accumulated previously using -Wa,.  */
5181           case 'Y':
5182             for (i = 0; i < n_assembler_options; i++)
5183               {
5184                 do_spec_1 (assembler_options[i], 1, NULL);
5185                 /* Make each accumulated option a separate argument.  */
5186                 do_spec_1 (" ", 0, NULL);
5187               }
5188             break;
5189
5190           /* Dump out the options accumulated previously using -Wp,.  */
5191           case 'Z':
5192             for (i = 0; i < n_preprocessor_options; i++)
5193               {
5194                 do_spec_1 (preprocessor_options[i], 1, NULL);
5195                 /* Make each accumulated option a separate argument.  */
5196                 do_spec_1 (" ", 0, NULL);
5197               }
5198             break;
5199
5200             /* Here are digits and numbers that just process
5201                a certain constant string as a spec.  */
5202
5203           case '1':
5204             value = do_spec_1 (cc1_spec, 0, NULL);
5205             if (value != 0)
5206               return value;
5207             break;
5208
5209           case '2':
5210             value = do_spec_1 (cc1plus_spec, 0, NULL);
5211             if (value != 0)
5212               return value;
5213             break;
5214
5215           case 'a':
5216             value = do_spec_1 (asm_spec, 0, NULL);
5217             if (value != 0)
5218               return value;
5219             break;
5220
5221           case 'A':
5222             value = do_spec_1 (asm_final_spec, 0, NULL);
5223             if (value != 0)
5224               return value;
5225             break;
5226
5227           case 'C':
5228             {
5229               const char *const spec
5230                 = (input_file_compiler->cpp_spec
5231                    ? input_file_compiler->cpp_spec
5232                    : cpp_spec);
5233               value = do_spec_1 (spec, 0, NULL);
5234               if (value != 0)
5235                 return value;
5236             }
5237             break;
5238
5239           case 'E':
5240             value = do_spec_1 (endfile_spec, 0, NULL);
5241             if (value != 0)
5242               return value;
5243             break;
5244
5245           case 'l':
5246             value = do_spec_1 (link_spec, 0, NULL);
5247             if (value != 0)
5248               return value;
5249             break;
5250
5251           case 'L':
5252             value = do_spec_1 (lib_spec, 0, NULL);
5253             if (value != 0)
5254               return value;
5255             break;
5256
5257           case 'G':
5258             value = do_spec_1 (libgcc_spec, 0, NULL);
5259             if (value != 0)
5260               return value;
5261             break;
5262
5263           case 'R':
5264             /* We assume there is a directory
5265                separator at the end of this string.  */
5266             if (target_system_root)
5267               {
5268                 obstack_grow (&obstack, target_system_root,
5269                               strlen (target_system_root));
5270                 if (target_sysroot_suffix)
5271                   obstack_grow (&obstack, target_sysroot_suffix,
5272                                 strlen (target_sysroot_suffix));
5273               }
5274             break;
5275
5276           case 'S':
5277             value = do_spec_1 (startfile_spec, 0, NULL);
5278             if (value != 0)
5279               return value;
5280             break;
5281
5282             /* Here we define characters other than letters and digits.  */
5283
5284           case '{':
5285             p = handle_braces (p);
5286             if (p == 0)
5287               return -1;
5288             break;
5289
5290           case ':':
5291             p = handle_spec_function (p);
5292             if (p == 0)
5293               return -1;
5294             break;
5295
5296           case '%':
5297             obstack_1grow (&obstack, '%');
5298             break;
5299
5300           case '.':
5301             {
5302               unsigned len = 0;
5303
5304               while (p[len] && p[len] != ' ' && p[len] != '%')
5305                 len++;
5306               suffix_subst = save_string (p - 1, len + 1);
5307               p += len;
5308             }
5309            break;
5310
5311            /* Henceforth ignore the option(s) matching the pattern
5312               after the %<.  */
5313           case '<':
5314             {
5315               unsigned len = 0;
5316               int have_wildcard = 0;
5317               int i;
5318
5319               while (p[len] && p[len] != ' ' && p[len] != '\t')
5320                 len++;
5321
5322               if (p[len-1] == '*')
5323                 have_wildcard = 1;
5324
5325               for (i = 0; i < n_switches; i++)
5326                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5327                     && (have_wildcard || switches[i].part1[len] == '\0'))
5328                   {
5329                     switches[i].live_cond = SWITCH_IGNORE;
5330                     switches[i].validated = 1;
5331                   }
5332
5333               p += len;
5334             }
5335             break;
5336
5337           case '*':
5338             if (soft_matched_part)
5339               {
5340                 do_spec_1 (soft_matched_part, 1, NULL);
5341                 do_spec_1 (" ", 0, NULL);
5342               }
5343             else
5344               /* Catch the case where a spec string contains something like
5345                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5346                  hand side of the :.  */
5347               error ("spec failure: '%%*' has not been initialized by pattern match");
5348             break;
5349
5350             /* Process a string found as the value of a spec given by name.
5351                This feature allows individual machine descriptions
5352                to add and use their own specs.
5353                %[...] modifies -D options the way %P does;
5354                %(...) uses the spec unmodified.  */
5355           case '[':
5356             error ("warning: use of obsolete %%[ operator in specs");
5357           case '(':
5358             {
5359               const char *name = p;
5360               struct spec_list *sl;
5361               int len;
5362
5363               /* The string after the S/P is the name of a spec that is to be
5364                  processed.  */
5365               while (*p && *p != ')' && *p != ']')
5366                 p++;
5367
5368               /* See if it's in the list.  */
5369               for (len = p - name, sl = specs; sl; sl = sl->next)
5370                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5371                   {
5372                     name = *(sl->ptr_spec);
5373 #ifdef DEBUG_SPECS
5374                     notice ("Processing spec %c%s%c, which is '%s'\n",
5375                             c, sl->name, (c == '(') ? ')' : ']', name);
5376 #endif
5377                     break;
5378                   }
5379
5380               if (sl)
5381                 {
5382                   if (c == '(')
5383                     {
5384                       value = do_spec_1 (name, 0, NULL);
5385                       if (value != 0)
5386                         return value;
5387                     }
5388                   else
5389                     {
5390                       char *x = alloca (strlen (name) * 2 + 1);
5391                       char *buf = x;
5392                       const char *y = name;
5393                       int flag = 0;
5394
5395                       /* Copy all of NAME into BUF, but put __ after
5396                          every -D and at the end of each arg.  */
5397                       while (1)
5398                         {
5399                           if (! strncmp (y, "-D", 2))
5400                             {
5401                               *x++ = '-';
5402                               *x++ = 'D';
5403                               *x++ = '_';
5404                               *x++ = '_';
5405                               y += 2;
5406                               flag = 1;
5407                               continue;
5408                             }
5409                           else if (flag
5410                                    && (*y == ' ' || *y == '\t' || *y == '='
5411                                        || *y == '}' || *y == 0))
5412                             {
5413                               *x++ = '_';
5414                               *x++ = '_';
5415                               flag = 0;
5416                             }
5417                           if (*y == 0)
5418                             break;
5419                           else
5420                             *x++ = *y++;
5421                         }
5422                       *x = 0;
5423
5424                       value = do_spec_1 (buf, 0, NULL);
5425                       if (value != 0)
5426                         return value;
5427                     }
5428                 }
5429
5430               /* Discard the closing paren or bracket.  */
5431               if (*p)
5432                 p++;
5433             }
5434             break;
5435
5436           default:
5437             error ("spec failure: unrecognized spec option '%c'", c);
5438             break;
5439           }
5440         break;
5441
5442       case '\\':
5443         /* Backslash: treat next character as ordinary.  */
5444         c = *p++;
5445
5446         /* Fall through.  */
5447       default:
5448         /* Ordinary character: put it into the current argument.  */
5449         obstack_1grow (&obstack, c);
5450         arg_going = 1;
5451       }
5452
5453   /* End of string.  If we are processing a spec function, we need to
5454      end any pending argument.  */
5455   if (processing_spec_function && arg_going)
5456     {
5457       obstack_1grow (&obstack, 0);
5458       string = XOBFINISH (&obstack, const char *);
5459       if (this_is_library_file)
5460         string = find_file (string);
5461       store_arg (string, delete_this_arg, this_is_output_file);
5462       if (this_is_output_file)
5463         outfiles[input_file_number] = string;
5464       arg_going = 0;
5465     }
5466
5467   return 0;
5468 }
5469
5470 /* Look up a spec function.  */
5471
5472 static const struct spec_function *
5473 lookup_spec_function (const char *name)
5474 {
5475   const struct spec_function *sf;
5476
5477   for (sf = static_spec_functions; sf->name != NULL; sf++)
5478     if (strcmp (sf->name, name) == 0)
5479       return sf;
5480
5481   return NULL;
5482 }
5483
5484 /* Evaluate a spec function.  */
5485
5486 static const char *
5487 eval_spec_function (const char *func, const char *args)
5488 {
5489   const struct spec_function *sf;
5490   const char *funcval;
5491
5492   /* Saved spec processing context.  */
5493   int save_argbuf_index;
5494   int save_argbuf_length;
5495   const char **save_argbuf;
5496
5497   int save_arg_going;
5498   int save_delete_this_arg;
5499   int save_this_is_output_file;
5500   int save_this_is_library_file;
5501   int save_input_from_pipe;
5502   const char *save_suffix_subst;
5503
5504
5505   sf = lookup_spec_function (func);
5506   if (sf == NULL)
5507     fatal ("unknown spec function '%s'", func);
5508
5509   /* Push the spec processing context.  */
5510   save_argbuf_index = argbuf_index;
5511   save_argbuf_length = argbuf_length;
5512   save_argbuf = argbuf;
5513
5514   save_arg_going = arg_going;
5515   save_delete_this_arg = delete_this_arg;
5516   save_this_is_output_file = this_is_output_file;
5517   save_this_is_library_file = this_is_library_file;
5518   save_input_from_pipe = input_from_pipe;
5519   save_suffix_subst = suffix_subst;
5520
5521   /* Create a new spec processing context, and build the function
5522      arguments.  */
5523
5524   alloc_args ();
5525   if (do_spec_2 (args) < 0)
5526     fatal ("error in args to spec function '%s'", func);
5527
5528   /* argbuf_index is an index for the next argument to be inserted, and
5529      so contains the count of the args already inserted.  */
5530
5531   funcval = (*sf->func) (argbuf_index, argbuf);
5532
5533   /* Pop the spec processing context.  */
5534   argbuf_index = save_argbuf_index;
5535   argbuf_length = save_argbuf_length;
5536   free (argbuf);
5537   argbuf = save_argbuf;
5538
5539   arg_going = save_arg_going;
5540   delete_this_arg = save_delete_this_arg;
5541   this_is_output_file = save_this_is_output_file;
5542   this_is_library_file = save_this_is_library_file;
5543   input_from_pipe = save_input_from_pipe;
5544   suffix_subst = save_suffix_subst;
5545
5546   return funcval;
5547 }
5548
5549 /* Handle a spec function call of the form:
5550
5551    %:function(args)
5552
5553    ARGS is processed as a spec in a separate context and split into an
5554    argument vector in the normal fashion.  The function returns a string
5555    containing a spec which we then process in the caller's context, or
5556    NULL if no processing is required.  */
5557
5558 static const char *
5559 handle_spec_function (const char *p)
5560 {
5561   char *func, *args;
5562   const char *endp, *funcval;
5563   int count;
5564
5565   processing_spec_function++;
5566
5567   /* Get the function name.  */
5568   for (endp = p; *endp != '\0'; endp++)
5569     {
5570       if (*endp == '(')         /* ) */
5571         break;
5572       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5573       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5574         fatal ("malformed spec function name");
5575     }
5576   if (*endp != '(')             /* ) */
5577     fatal ("no arguments for spec function");
5578   func = save_string (p, endp - p);
5579   p = ++endp;
5580
5581   /* Get the arguments.  */
5582   for (count = 0; *endp != '\0'; endp++)
5583     {
5584       /* ( */
5585       if (*endp == ')')
5586         {
5587           if (count == 0)
5588             break;
5589           count--;
5590         }
5591       else if (*endp == '(')    /* ) */
5592         count++;
5593     }
5594   /* ( */
5595   if (*endp != ')')
5596     fatal ("malformed spec function arguments");
5597   args = save_string (p, endp - p);
5598   p = ++endp;
5599
5600   /* p now points to just past the end of the spec function expression.  */
5601
5602   funcval = eval_spec_function (func, args);
5603   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5604     p = NULL;
5605
5606   free (func);
5607   free (args);
5608
5609   processing_spec_function--;
5610
5611   return p;
5612 }
5613
5614 /* Inline subroutine of handle_braces.  Returns true if the current
5615    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5616 static inline bool
5617 input_suffix_matches (const char *atom, const char *end_atom)
5618 {
5619   /* We special case the semantics of {.s:...} and {.S:...} and their
5620      negative variants.  Instead of testing the input filename suffix,
5621      we test whether the input source file is an assembler file or an
5622      assembler-with-cpp file respectively.  This allows us to correctly
5623      handle the -x command line option.  */
5624
5625   if (atom + 1 == end_atom
5626       && input_file_compiler
5627       && input_file_compiler->suffix)
5628     {
5629       if (*atom == 's')
5630         return !strcmp (input_file_compiler->suffix, "@assembler");
5631       if (*atom == 'S')
5632         return !strcmp (input_file_compiler->suffix, "@assembler-with-cpp");
5633     }
5634
5635   return (input_suffix
5636           && !strncmp (input_suffix, atom, end_atom - atom)
5637           && input_suffix[end_atom - atom] == '\0');
5638 }
5639
5640 /* Subroutine of handle_braces.  Returns true if a switch
5641    matching the atom bracketed by ATOM and END_ATOM appeared on the
5642    command line.  */
5643 static bool
5644 switch_matches (const char *atom, const char *end_atom, int starred)
5645 {
5646   int i;
5647   int len = end_atom - atom;
5648   int plen = starred ? len : -1;
5649
5650   for (i = 0; i < n_switches; i++)
5651     if (!strncmp (switches[i].part1, atom, len)
5652         && (starred || switches[i].part1[len] == '\0')
5653         && check_live_switch (i, plen))
5654       return true;
5655
5656   return false;
5657 }
5658
5659 /* Inline subroutine of handle_braces.  Mark all of the switches which
5660    match ATOM (extends to END_ATOM; STARRED indicates whether there
5661    was a star after the atom) for later processing.  */
5662 static inline void
5663 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5664 {
5665   int i;
5666   int len = end_atom - atom;
5667   int plen = starred ? len : -1;
5668
5669   for (i = 0; i < n_switches; i++)
5670     if (!strncmp (switches[i].part1, atom, len)
5671         && (starred || switches[i].part1[len] == '\0')
5672         && check_live_switch (i, plen))
5673       switches[i].ordering = 1;
5674 }
5675
5676 /* Inline subroutine of handle_braces.  Process all the currently
5677    marked switches through give_switch, and clear the marks.  */
5678 static inline void
5679 process_marked_switches (void)
5680 {
5681   int i;
5682
5683   for (i = 0; i < n_switches; i++)
5684     if (switches[i].ordering == 1)
5685       {
5686         switches[i].ordering = 0;
5687         give_switch (i, 0);
5688       }
5689 }
5690
5691 /* Handle a %{ ... } construct.  P points just inside the leading {.
5692    Returns a pointer one past the end of the brace block, or 0
5693    if we call do_spec_1 and that returns -1.  */
5694
5695 static const char *
5696 handle_braces (const char *p)
5697 {
5698   const char *atom, *end_atom;
5699   const char *d_atom = NULL, *d_end_atom = NULL;
5700   const char *orig = p;
5701
5702   bool a_is_suffix;
5703   bool a_is_starred;
5704   bool a_is_negated;
5705   bool a_matched;
5706
5707   bool a_must_be_last = false;
5708   bool ordered_set    = false;
5709   bool disjunct_set   = false;
5710   bool disj_matched   = false;
5711   bool disj_starred   = true;
5712   bool n_way_choice   = false;
5713   bool n_way_matched  = false;
5714
5715 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5716
5717   do
5718     {
5719       if (a_must_be_last)
5720         goto invalid;
5721
5722       /* Scan one "atom" (S in the description above of %{}, possibly
5723          with !, ., or * modifiers).  */
5724       a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5725
5726       SKIP_WHITE();
5727       if (*p == '!')
5728         p++, a_is_negated = true;
5729
5730       SKIP_WHITE();
5731       if (*p == '.')
5732         p++, a_is_suffix = true;
5733
5734       atom = p;
5735       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5736              || *p == ',' || *p == '.' || *p == '@')
5737         p++;
5738       end_atom = p;
5739
5740       if (*p == '*')
5741         p++, a_is_starred = 1;
5742
5743       SKIP_WHITE();
5744       switch (*p)
5745         {
5746         case '&': case '}':
5747           /* Substitute the switch(es) indicated by the current atom.  */
5748           ordered_set = true;
5749           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5750               || atom == end_atom)
5751             goto invalid;
5752
5753           mark_matching_switches (atom, end_atom, a_is_starred);
5754
5755           if (*p == '}')
5756             process_marked_switches ();
5757           break;
5758
5759         case '|': case ':':
5760           /* Substitute some text if the current atom appears as a switch
5761              or suffix.  */
5762           disjunct_set = true;
5763           if (ordered_set)
5764             goto invalid;
5765
5766           if (atom == end_atom)
5767             {
5768               if (!n_way_choice || disj_matched || *p == '|'
5769                   || a_is_negated || a_is_suffix || a_is_starred)
5770                 goto invalid;
5771
5772               /* An empty term may appear as the last choice of an
5773                  N-way choice set; it means "otherwise".  */
5774               a_must_be_last = true;
5775               disj_matched = !n_way_matched;
5776               disj_starred = false;
5777             }
5778           else
5779             {
5780                if (a_is_suffix && a_is_starred)
5781                  goto invalid;
5782
5783                if (!a_is_starred)
5784                  disj_starred = false;
5785
5786                /* Don't bother testing this atom if we already have a
5787                   match.  */
5788                if (!disj_matched && !n_way_matched)
5789                  {
5790                    if (a_is_suffix)
5791                      a_matched = input_suffix_matches (atom, end_atom);
5792                    else
5793                      a_matched = switch_matches (atom, end_atom, a_is_starred);
5794
5795                    if (a_matched != a_is_negated)
5796                      {
5797                        disj_matched = true;
5798                        d_atom = atom;
5799                        d_end_atom = end_atom;
5800                      }
5801                  }
5802             }
5803
5804           if (*p == ':')
5805             {
5806               /* Found the body, that is, the text to substitute if the
5807                  current disjunction matches.  */
5808               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5809                                       disj_matched && !n_way_matched);
5810               if (p == 0)
5811                 return 0;
5812
5813               /* If we have an N-way choice, reset state for the next
5814                  disjunction.  */
5815               if (*p == ';')
5816                 {
5817                   n_way_choice = true;
5818                   n_way_matched |= disj_matched;
5819                   disj_matched = false;
5820                   disj_starred = true;
5821                   d_atom = d_end_atom = NULL;
5822                 }
5823             }
5824           break;
5825
5826         default:
5827           goto invalid;
5828         }
5829     }
5830   while (*p++ != '}');
5831
5832   return p;
5833
5834  invalid:
5835   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
5836
5837 #undef SKIP_WHITE
5838 }
5839
5840 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5841    (X in the description of %{} syntax).  P points one past the colon;
5842    ATOM and END_ATOM bracket the first atom which was found to be true
5843    (present) in the current disjunction; STARRED indicates whether all
5844    the atoms in the current disjunction were starred (for syntax validation);
5845    MATCHED indicates whether the disjunction matched or not, and therefore
5846    whether or not the body is to be processed through do_spec_1 or just
5847    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5848    returns -1.  */
5849
5850 static const char *
5851 process_brace_body (const char *p, const char *atom, const char *end_atom,
5852                     int starred, int matched)
5853 {
5854   const char *body, *end_body;
5855   unsigned int nesting_level;
5856   bool have_subst     = false;
5857
5858   /* Locate the closing } or ;, honoring nested braces.
5859      Trim trailing whitespace.  */
5860   body = p;
5861   nesting_level = 1;
5862   for (;;)
5863     {
5864       if (*p == '{')
5865         nesting_level++;
5866       else if (*p == '}')
5867         {
5868           if (!--nesting_level)
5869             break;
5870         }
5871       else if (*p == ';' && nesting_level == 1)
5872         break;
5873       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5874         have_subst = true;
5875       else if (*p == '\0')
5876         goto invalid;
5877       p++;
5878     }
5879
5880   end_body = p;
5881   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5882     end_body--;
5883
5884   if (have_subst && !starred)
5885     goto invalid;
5886
5887   if (matched)
5888     {
5889       /* Copy the substitution body to permanent storage and execute it.
5890          If have_subst is false, this is a simple matter of running the
5891          body through do_spec_1...  */
5892       char *string = save_string (body, end_body - body);
5893       if (!have_subst)
5894         {
5895           if (do_spec_1 (string, 0, NULL) < 0)
5896             return 0;
5897         }
5898       else
5899         {
5900           /* ... but if have_subst is true, we have to process the
5901              body once for each matching switch, with %* set to the
5902              variant part of the switch.  */
5903           unsigned int hard_match_len = end_atom - atom;
5904           int i;
5905
5906           for (i = 0; i < n_switches; i++)
5907             if (!strncmp (switches[i].part1, atom, hard_match_len)
5908                 && check_live_switch (i, hard_match_len))
5909               {
5910                 if (do_spec_1 (string, 0,
5911                                &switches[i].part1[hard_match_len]) < 0)
5912                   return 0;
5913                 /* Pass any arguments this switch has.  */
5914                 give_switch (i, 1);
5915                 suffix_subst = NULL;
5916               }
5917         }
5918     }
5919
5920   return p;
5921
5922  invalid:
5923   fatal ("braced spec body '%s' is invalid", body);
5924 }
5925 \f
5926 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5927    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5928    spec, or -1 if either exact match or %* is used.
5929
5930    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5931    whose value does not begin with "no-" is obsoleted by the same value
5932    with the "no-", similarly for a switch with the "no-" prefix.  */
5933
5934 static int
5935 check_live_switch (int switchnum, int prefix_length)
5936 {
5937   const char *name = switches[switchnum].part1;
5938   int i;
5939
5940   /* In the common case of {<at-most-one-letter>*}, a negating
5941      switch would always match, so ignore that case.  We will just
5942      send the conflicting switches to the compiler phase.  */
5943   if (prefix_length >= 0 && prefix_length <= 1)
5944     return 1;
5945
5946   /* If we already processed this switch and determined if it was
5947      live or not, return our past determination.  */
5948   if (switches[switchnum].live_cond != 0)
5949     return switches[switchnum].live_cond > 0;
5950
5951   /* Now search for duplicate in a manner that depends on the name.  */
5952   switch (*name)
5953     {
5954     case 'O':
5955       for (i = switchnum + 1; i < n_switches; i++)
5956         if (switches[i].part1[0] == 'O')
5957           {
5958             switches[switchnum].validated = 1;
5959             switches[switchnum].live_cond = SWITCH_FALSE;
5960             return 0;
5961           }
5962       break;
5963
5964     case 'W':  case 'f':  case 'm':
5965       if (! strncmp (name + 1, "no-", 3))
5966         {
5967           /* We have Xno-YYY, search for XYYY.  */
5968           for (i = switchnum + 1; i < n_switches; i++)
5969             if (switches[i].part1[0] == name[0]
5970                 && ! strcmp (&switches[i].part1[1], &name[4]))
5971               {
5972                 switches[switchnum].validated = 1;
5973                 switches[switchnum].live_cond = SWITCH_FALSE;
5974                 return 0;
5975               }
5976         }
5977       else
5978         {
5979           /* We have XYYY, search for Xno-YYY.  */
5980           for (i = switchnum + 1; i < n_switches; i++)
5981             if (switches[i].part1[0] == name[0]
5982                 && switches[i].part1[1] == 'n'
5983                 && switches[i].part1[2] == 'o'
5984                 && switches[i].part1[3] == '-'
5985                 && !strcmp (&switches[i].part1[4], &name[1]))
5986               {
5987                 switches[switchnum].validated = 1;
5988                 switches[switchnum].live_cond = SWITCH_FALSE;
5989                 return 0;
5990               }
5991         }
5992       break;
5993     }
5994
5995   /* Otherwise the switch is live.  */
5996   switches[switchnum].live_cond = SWITCH_LIVE;
5997   return 1;
5998 }
5999 \f
6000 /* Pass a switch to the current accumulating command
6001    in the same form that we received it.
6002    SWITCHNUM identifies the switch; it is an index into
6003    the vector of switches gcc received, which is `switches'.
6004    This cannot fail since it never finishes a command line.
6005
6006    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
6007
6008 static void
6009 give_switch (int switchnum, int omit_first_word)
6010 {
6011   if (switches[switchnum].live_cond == SWITCH_IGNORE)
6012     return;
6013
6014   if (!omit_first_word)
6015     {
6016       do_spec_1 ("-", 0, NULL);
6017       do_spec_1 (switches[switchnum].part1, 1, NULL);
6018     }
6019
6020   if (switches[switchnum].args != 0)
6021     {
6022       const char **p;
6023       for (p = switches[switchnum].args; *p; p++)
6024         {
6025           const char *arg = *p;
6026
6027           do_spec_1 (" ", 0, NULL);
6028           if (suffix_subst)
6029             {
6030               unsigned length = strlen (arg);
6031               int dot = 0;
6032
6033               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6034                 if (arg[length] == '.')
6035                   {
6036                     ((char *)arg)[length] = 0;
6037                     dot = 1;
6038                     break;
6039                   }
6040               do_spec_1 (arg, 1, NULL);
6041               if (dot)
6042                 ((char *)arg)[length] = '.';
6043               do_spec_1 (suffix_subst, 1, NULL);
6044             }
6045           else
6046             do_spec_1 (arg, 1, NULL);
6047         }
6048     }
6049
6050   do_spec_1 (" ", 0, NULL);
6051   switches[switchnum].validated = 1;
6052 }
6053 \f
6054 /* Search for a file named NAME trying various prefixes including the
6055    user's -B prefix and some standard ones.
6056    Return the absolute file name found.  If nothing is found, return NAME.  */
6057
6058 static const char *
6059 find_file (const char *name)
6060 {
6061   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6062   return newname ? newname : name;
6063 }
6064
6065 /* Determine whether a directory exists.  If LINKER, return 0 for
6066    certain fixed names not needed by the linker.  */
6067
6068 static int
6069 is_directory (const char *path1, bool linker)
6070 {
6071   int len1;
6072   char *path;
6073   char *cp;
6074   struct stat st;
6075
6076   /* Ensure the string ends with "/.".  The resulting path will be a
6077      directory even if the given path is a symbolic link.  */
6078   len1 = strlen (path1);
6079   path = alloca (3 + len1);
6080   memcpy (path, path1, len1);
6081   cp = path + len1;
6082   if (!IS_DIR_SEPARATOR (cp[-1]))
6083     *cp++ = DIR_SEPARATOR;
6084   *cp++ = '.';
6085   *cp = '\0';
6086
6087 #ifndef FREEBSD_NATIVE
6088   /* Exclude directories that the linker is known to search.  */
6089   if (linker
6090       && IS_DIR_SEPARATOR (path[0])
6091       && ((cp - path == 6
6092            && strncmp (path + 1, "lib", 3) == 0)
6093           || (cp - path == 10
6094               && strncmp (path + 1, "usr", 3) == 0
6095               && IS_DIR_SEPARATOR (path[4])
6096               && strncmp (path + 5, "lib", 3) == 0)))
6097     return 0;
6098 #endif /* FREEBSD_NATIVE */
6099
6100   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6101 }
6102
6103 /* Set up the various global variables to indicate that we're processing
6104    the input file named FILENAME.  */
6105
6106 void
6107 set_input (const char *filename)
6108 {
6109   const char *p;
6110
6111   input_filename = filename;
6112   input_filename_length = strlen (input_filename);
6113
6114   input_basename = input_filename;
6115 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
6116   /* Skip drive name so 'x:foo' is handled properly.  */
6117   if (input_basename[1] == ':')
6118     input_basename += 2;
6119 #endif
6120   for (p = input_basename; *p; p++)
6121     if (IS_DIR_SEPARATOR (*p))
6122       input_basename = p + 1;
6123
6124   /* Find a suffix starting with the last period,
6125      and set basename_length to exclude that suffix.  */
6126   basename_length = strlen (input_basename);
6127   suffixed_basename_length = basename_length;
6128   p = input_basename + basename_length;
6129   while (p != input_basename && *p != '.')
6130     --p;
6131   if (*p == '.' && p != input_basename)
6132     {
6133       basename_length = p - input_basename;
6134       input_suffix = p + 1;
6135     }
6136   else
6137     input_suffix = "";
6138
6139   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6140      we will need to do a stat on the input_filename.  The
6141      INPUT_STAT_SET signals that the stat is needed.  */
6142   input_stat_set = 0;
6143 }
6144 \f
6145 /* On fatal signals, delete all the temporary files.  */
6146
6147 static void
6148 fatal_error (int signum)
6149 {
6150   signal (signum, SIG_DFL);
6151   delete_failure_queue ();
6152   delete_temp_files ();
6153   /* Get the same signal again, this time not handled,
6154      so its normal effect occurs.  */
6155   kill (getpid (), signum);
6156 }
6157
6158 extern int main (int, char **);
6159
6160 int
6161 main (int argc, char **argv)
6162 {
6163   size_t i;
6164   int value;
6165   int linker_was_run = 0;
6166   int lang_n_infiles = 0;
6167   int num_linker_inputs = 0;
6168   char *explicit_link_files;
6169   char *specs_file;
6170   const char *p;
6171   struct user_specs *uptr;
6172
6173   p = argv[0] + strlen (argv[0]);
6174   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6175     --p;
6176   programname = p;
6177
6178   xmalloc_set_program_name (programname);
6179
6180   expandargv (&argc, &argv);
6181
6182   prune_options (&argc, &argv);
6183
6184 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6185   /* Perform host dependent initialization when needed.  */
6186   GCC_DRIVER_HOST_INITIALIZATION;
6187 #endif
6188
6189   /* Unlock the stdio streams.  */
6190   unlock_std_streams ();
6191
6192   gcc_init_libintl ();
6193
6194   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6195     signal (SIGINT, fatal_error);
6196 #ifdef SIGHUP
6197   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6198     signal (SIGHUP, fatal_error);
6199 #endif
6200   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6201     signal (SIGTERM, fatal_error);
6202 #ifdef SIGPIPE
6203   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6204     signal (SIGPIPE, fatal_error);
6205 #endif
6206 #ifdef SIGCHLD
6207   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6208      receive the signal.  A different setting is inheritable */
6209   signal (SIGCHLD, SIG_DFL);
6210 #endif
6211
6212   /* Allocate the argument vector.  */
6213   alloc_args ();
6214
6215   obstack_init (&obstack);
6216
6217   /* Build multilib_select, et. al from the separate lines that make up each
6218      multilib selection.  */
6219   {
6220     const char *const *q = multilib_raw;
6221     int need_space;
6222
6223     obstack_init (&multilib_obstack);
6224     while ((p = *q++) != (char *) 0)
6225       obstack_grow (&multilib_obstack, p, strlen (p));
6226
6227     obstack_1grow (&multilib_obstack, 0);
6228     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6229
6230     q = multilib_matches_raw;
6231     while ((p = *q++) != (char *) 0)
6232       obstack_grow (&multilib_obstack, p, strlen (p));
6233
6234     obstack_1grow (&multilib_obstack, 0);
6235     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6236
6237     q = multilib_exclusions_raw;
6238     while ((p = *q++) != (char *) 0)
6239       obstack_grow (&multilib_obstack, p, strlen (p));
6240
6241     obstack_1grow (&multilib_obstack, 0);
6242     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6243
6244     need_space = FALSE;
6245     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6246       {
6247         if (need_space)
6248           obstack_1grow (&multilib_obstack, ' ');
6249         obstack_grow (&multilib_obstack,
6250                       multilib_defaults_raw[i],
6251                       strlen (multilib_defaults_raw[i]));
6252         need_space = TRUE;
6253       }
6254
6255     obstack_1grow (&multilib_obstack, 0);
6256     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6257   }
6258
6259   /* Set up to remember the pathname of gcc and any options
6260      needed for collect.  We use argv[0] instead of programname because
6261      we need the complete pathname.  */
6262   obstack_init (&collect_obstack);
6263   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6264   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6265   putenv (XOBFINISH (&collect_obstack, char *));
6266
6267 #ifdef INIT_ENVIRONMENT
6268   /* Set up any other necessary machine specific environment variables.  */
6269   putenv (INIT_ENVIRONMENT);
6270 #endif
6271
6272   /* Make a table of what switches there are (switches, n_switches).
6273      Make a table of specified input files (infiles, n_infiles).
6274      Decode switches that are handled locally.  */
6275
6276   process_command (argc, (const char **) argv);
6277
6278   /* Initialize the vector of specs to just the default.
6279      This means one element containing 0s, as a terminator.  */
6280
6281   compilers = xmalloc (sizeof default_compilers);
6282   memcpy (compilers, default_compilers, sizeof default_compilers);
6283   n_compilers = n_default_compilers;
6284
6285   /* Read specs from a file if there is one.  */
6286
6287 #ifdef FREEBSD_NATIVE
6288   machine_suffix = "";
6289   just_machine_suffix = "";
6290 #else   /* FREEBSD_NATIVE */
6291   machine_suffix = concat (spec_machine, dir_separator_str,
6292                            spec_version, dir_separator_str, NULL);
6293   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6294 #endif /* FREEBSD_NATIVE */
6295
6296   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6297   /* Read the specs file unless it is a default one.  */
6298   if (specs_file != 0 && strcmp (specs_file, "specs"))
6299     read_specs (specs_file, TRUE);
6300   else
6301     init_spec ();
6302
6303   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6304      for any override of as, ld and libraries.  */
6305   specs_file = (char *) alloca (strlen (FBSD_DATA_PREFIX)
6306                                 + strlen (just_machine_suffix)
6307                                 + sizeof ("specs"));
6308
6309   strcpy (specs_file, FBSD_DATA_PREFIX);
6310   strcat (specs_file, just_machine_suffix);
6311   strcat (specs_file, "specs");
6312   if (access (specs_file, R_OK) == 0)
6313     read_specs (specs_file, TRUE);
6314
6315   /* Process any configure-time defaults specified for the command line
6316      options, via OPTION_DEFAULT_SPECS.  */
6317   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6318     do_option_spec (option_default_specs[i].name,
6319                     option_default_specs[i].spec);
6320
6321   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6322      of the command line.  */
6323
6324   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6325     do_self_spec (driver_self_specs[i]);
6326
6327   /* If not cross-compiling, look for executables in the standard
6328      places.  */
6329   if (*cross_compile == '0')
6330     {
6331       if (*md_exec_prefix)
6332         {
6333           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6334                       PREFIX_PRIORITY_LAST, 0, 0);
6335         }
6336     }
6337
6338   /* Process sysroot_suffix_spec.  */
6339   if (*sysroot_suffix_spec != 0
6340       && do_spec_2 (sysroot_suffix_spec) == 0)
6341     {
6342       if (argbuf_index > 1)
6343         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6344       else if (argbuf_index == 1)
6345         target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6346     }
6347
6348 #ifdef HAVE_LD_SYSROOT
6349   /* Pass the --sysroot option to the linker, if it supports that.  If
6350      there is a sysroot_suffix_spec, it has already been processed by
6351      this point, so target_system_root really is the system root we
6352      should be using.  */
6353   if (target_system_root)
6354     {
6355       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6356       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6357       set_spec ("link", XOBFINISH (&obstack, const char *));
6358     }
6359 #endif
6360
6361   /* Process sysroot_hdrs_suffix_spec.  */
6362   if (*sysroot_hdrs_suffix_spec != 0
6363       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6364     {
6365       if (argbuf_index > 1)
6366         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6367       else if (argbuf_index == 1)
6368         target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6369     }
6370
6371   /* Look for startfiles in the standard places.  */
6372   if (*startfile_prefix_spec != 0
6373       && do_spec_2 (startfile_prefix_spec) == 0
6374       && do_spec_1 (" ", 0, NULL) == 0)
6375     {
6376       int ndx;
6377       for (ndx = 0; ndx < argbuf_index; ndx++)
6378         add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6379                               PREFIX_PRIORITY_LAST, 0, 1);
6380     }
6381   /* We should eventually get rid of all these and stick to
6382      startfile_prefix_spec exclusively.  */
6383   else if (*cross_compile == '0' || target_system_root)
6384     {
6385       if (*md_startfile_prefix)
6386         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6387                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6388
6389       if (*md_startfile_prefix_1)
6390         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6391                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6392
6393       /* If standard_startfile_prefix is relative, base it on
6394          standard_exec_prefix.  This lets us move the installed tree
6395          as a unit.  If GCC_EXEC_PREFIX is defined, base
6396          standard_startfile_prefix on that as well.
6397
6398          If the prefix is relative, only search it for native compilers;
6399          otherwise we will search a directory containing host libraries.  */
6400       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6401         add_sysrooted_prefix (&startfile_prefixes,
6402                               standard_startfile_prefix, "BINUTILS",
6403                               PREFIX_PRIORITY_LAST, 0, 1);
6404       else if (*cross_compile == '0')
6405         {
6406           if (gcc_exec_prefix)
6407             add_prefix (&startfile_prefixes,
6408                         concat (gcc_exec_prefix, machine_suffix,
6409                                 standard_startfile_prefix, NULL),
6410                         NULL, PREFIX_PRIORITY_LAST, 0, 1);
6411           add_prefix (&startfile_prefixes,
6412                       concat (standard_exec_prefix,
6413                               machine_suffix,
6414                               standard_startfile_prefix, NULL),
6415                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6416         }
6417
6418 #ifndef FREEBSD_NATIVE
6419       if (*standard_startfile_prefix_1)
6420         add_sysrooted_prefix (&startfile_prefixes,
6421                               standard_startfile_prefix_1, "BINUTILS",
6422                               PREFIX_PRIORITY_LAST, 0, 1);
6423       if (*standard_startfile_prefix_2)
6424         add_sysrooted_prefix (&startfile_prefixes,
6425                               standard_startfile_prefix_2, "BINUTILS",
6426                               PREFIX_PRIORITY_LAST, 0, 1);
6427 #endif
6428     }
6429
6430   /* Process any user specified specs in the order given on the command
6431      line.  */
6432   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6433     {
6434       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6435                                     R_OK, true);
6436       read_specs (filename ? filename : uptr->filename, FALSE);
6437     }
6438
6439   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6440   if (gcc_exec_prefix)
6441     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6442                               spec_version, dir_separator_str, NULL);
6443
6444   /* Now we have the specs.
6445      Set the `valid' bits for switches that match anything in any spec.  */
6446
6447   validate_all_switches ();
6448
6449   /* Now that we have the switches and the specs, set
6450      the subdirectory based on the options.  */
6451   set_multilib_dir ();
6452
6453   /* Warn about any switches that no pass was interested in.  */
6454
6455   for (i = 0; (int) i < n_switches; i++)
6456     if (! switches[i].validated)
6457       error ("unrecognized option '-%s'", switches[i].part1);
6458
6459   /* Obey some of the options.  */
6460
6461   if (print_search_dirs)
6462     {
6463 #ifndef FREEBSD_NATIVE
6464       printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6465 #else
6466       printf (_("install: %s\n"), standard_exec_prefix);
6467 #endif
6468       printf (_("programs: %s\n"),
6469               build_search_list (&exec_prefixes, "", false, false));
6470       printf (_("libraries: %s\n"),
6471               build_search_list (&startfile_prefixes, "", false, true));
6472       return (0);
6473     }
6474
6475   if (print_file_name)
6476     {
6477       printf ("%s\n", find_file (print_file_name));
6478       return (0);
6479     }
6480
6481   if (print_prog_name)
6482     {
6483       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6484       printf ("%s\n", (newname ? newname : print_prog_name));
6485       return (0);
6486     }
6487
6488   if (print_multi_lib)
6489     {
6490       print_multilib_info ();
6491       return (0);
6492     }
6493
6494   if (print_multi_directory)
6495     {
6496       if (multilib_dir == NULL)
6497         printf (".\n");
6498       else
6499         printf ("%s\n", multilib_dir);
6500       return (0);
6501     }
6502
6503   if (print_multi_os_directory)
6504     {
6505       if (multilib_os_dir == NULL)
6506         printf (".\n");
6507       else
6508         printf ("%s\n", multilib_os_dir);
6509       return (0);
6510     }
6511
6512   if (target_help_flag)
6513    {
6514       /* Print if any target specific options.  */
6515
6516       /* We do not exit here. Instead we have created a fake input file
6517          called 'target-dummy' which needs to be compiled, and we pass this
6518          on to the various sub-processes, along with the --target-help
6519          switch.  */
6520     }
6521
6522   if (print_help_list)
6523     {
6524       display_help ();
6525
6526       if (! verbose_flag)
6527         {
6528           printf ("%s", _("\nFor bug reporting instructions, please see:\n"));
6529           printf ("%s.\n", bug_report_url);
6530
6531           return (0);
6532         }
6533
6534       /* We do not exit here.  Instead we have created a fake input file
6535          called 'help-dummy' which needs to be compiled, and we pass this
6536          on the various sub-processes, along with the --help switch.  */
6537     }
6538
6539   if (verbose_flag)
6540     {
6541       int n;
6542       const char *thrmod;
6543
6544       notice ("Target: %s\n", spec_machine);
6545       notice ("Configured with: %s\n", configuration_arguments);
6546
6547 #ifdef THREAD_MODEL_SPEC
6548       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6549          but there's no point in doing all this processing just to get
6550          thread_model back.  */
6551       obstack_init (&obstack);
6552       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6553       obstack_1grow (&obstack, '\0');
6554       thrmod = XOBFINISH (&obstack, const char *);
6555 #else
6556       thrmod = thread_model;
6557 #endif
6558
6559       notice ("Thread model: %s\n", thrmod);
6560
6561       /* compiler_version is truncated at the first space when initialized
6562          from version string, so truncate version_string at the first space
6563          before comparing.  */
6564       for (n = 0; version_string[n]; n++)
6565         if (version_string[n] == ' ')
6566           break;
6567
6568       if (! strncmp (version_string, compiler_version, n)
6569           && compiler_version[n] == 0)
6570         notice ("gcc version %s\n", version_string);
6571       else
6572         notice ("gcc driver version %s executing gcc version %s\n",
6573                 version_string, compiler_version);
6574
6575       if (n_infiles == 0)
6576         return (0);
6577     }
6578
6579   if (n_infiles == added_libraries)
6580     fatal ("No input files specified");
6581
6582   /* Make a place to record the compiler output file names
6583      that correspond to the input files.  */
6584
6585   i = n_infiles;
6586   i += lang_specific_extra_outfiles;
6587   outfiles = XCNEWVEC (const char *, i);
6588
6589   /* Record which files were specified explicitly as link input.  */
6590
6591   explicit_link_files = XCNEWVEC (char, n_infiles);
6592
6593   if (combine_flag)
6594     combine_inputs = true;
6595   else
6596     combine_inputs = false;
6597
6598   for (i = 0; (int) i < n_infiles; i++)
6599     {
6600       const char *name = infiles[i].name;
6601       struct compiler *compiler = lookup_compiler (name,
6602                                                    strlen (name),
6603                                                    infiles[i].language);
6604
6605       if (compiler && !(compiler->combinable))
6606         combine_inputs = false;
6607
6608       if (lang_n_infiles > 0 && compiler != input_file_compiler
6609           && infiles[i].language && infiles[i].language[0] != '*')
6610         infiles[i].incompiler = compiler;
6611       else if (compiler)
6612         {
6613           lang_n_infiles++;
6614           input_file_compiler = compiler;
6615           infiles[i].incompiler = compiler;
6616         }
6617       else
6618         {
6619           /* Since there is no compiler for this input file, assume it is a
6620              linker file.  */
6621           explicit_link_files[i] = 1;
6622           infiles[i].incompiler = NULL;
6623         }
6624       infiles[i].compiled = false;
6625       infiles[i].preprocessed = false;
6626     }
6627
6628   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6629    fatal ("cannot specify -o with -c or -S with multiple files");
6630
6631   if (combine_flag && save_temps_flag)
6632     {
6633       bool save_combine_inputs = combine_inputs;
6634       /* Must do a separate pre-processing pass for C & Objective-C files, to
6635          obtain individual .i files.  */
6636
6637       combine_inputs = false;
6638       for (i = 0; (int) i < n_infiles; i++)
6639         {
6640           int this_file_error = 0;
6641
6642           input_file_number = i;
6643           set_input (infiles[i].name);
6644           if (infiles[i].incompiler
6645               && (infiles[i].incompiler)->needs_preprocessing)
6646             input_file_compiler = infiles[i].incompiler;
6647           else
6648             continue;
6649
6650           if (input_file_compiler)
6651             {
6652               if (input_file_compiler->spec[0] == '#')
6653                 {
6654                   error ("%s: %s compiler not installed on this system",
6655                          input_filename, &input_file_compiler->spec[1]);
6656                   this_file_error = 1;
6657                 }
6658               else
6659                 {
6660                   value = do_spec (input_file_compiler->spec);
6661                   infiles[i].preprocessed = true;
6662                   if (!have_o_argbuf_index)
6663                     fatal ("spec '%s' is invalid", input_file_compiler->spec);
6664                   infiles[i].name = argbuf[have_o_argbuf_index];
6665                   infiles[i].incompiler
6666                     = lookup_compiler (infiles[i].name,
6667                                        strlen (infiles[i].name),
6668                                        infiles[i].language);
6669
6670                   if (value < 0)
6671                     this_file_error = 1;
6672                 }
6673             }
6674
6675           if (this_file_error)
6676             {
6677               delete_failure_queue ();
6678               error_count++;
6679               break;
6680             }
6681           clear_failure_queue ();
6682         }
6683       combine_inputs = save_combine_inputs;
6684     }
6685
6686   for (i = 0; (int) i < n_infiles; i++)
6687     {
6688       int this_file_error = 0;
6689
6690       /* Tell do_spec what to substitute for %i.  */
6691
6692       input_file_number = i;
6693       set_input (infiles[i].name);
6694
6695       if (infiles[i].compiled)
6696         continue;
6697
6698       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6699
6700       outfiles[i] = input_filename;
6701
6702       /* Figure out which compiler from the file's suffix.  */
6703
6704       if (! combine_inputs)
6705         input_file_compiler
6706           = lookup_compiler (infiles[i].name, input_filename_length,
6707                              infiles[i].language);
6708       else
6709         input_file_compiler = infiles[i].incompiler;
6710
6711       if (input_file_compiler)
6712         {
6713           /* Ok, we found an applicable compiler.  Run its spec.  */
6714
6715           if (input_file_compiler->spec[0] == '#')
6716             {
6717               error ("%s: %s compiler not installed on this system",
6718                      input_filename, &input_file_compiler->spec[1]);
6719               this_file_error = 1;
6720             }
6721           else
6722             {
6723               value = do_spec (input_file_compiler->spec);
6724               infiles[i].compiled = true;
6725               if (value < 0)
6726                 this_file_error = 1;
6727             }
6728         }
6729
6730       /* If this file's name does not contain a recognized suffix,
6731          record it as explicit linker input.  */
6732
6733       else
6734         explicit_link_files[i] = 1;
6735
6736       /* Clear the delete-on-failure queue, deleting the files in it
6737          if this compilation failed.  */
6738
6739       if (this_file_error)
6740         {
6741           delete_failure_queue ();
6742           error_count++;
6743         }
6744       /* If this compilation succeeded, don't delete those files later.  */
6745       clear_failure_queue ();
6746     }
6747
6748   /* Reset the input file name to the first compile/object file name, for use
6749      with %b in LINK_SPEC. We use the first input file that we can find
6750      a compiler to compile it instead of using infiles.language since for
6751      languages other than C we use aliases that we then lookup later.  */
6752   if (n_infiles > 0)
6753     {
6754       int i;
6755
6756       for (i = 0; i < n_infiles ; i++)
6757         if (infiles[i].language && infiles[i].language[0] != '*')
6758           {
6759             set_input (infiles[i].name);
6760             break;
6761           }
6762     }
6763
6764   if (error_count == 0)
6765     {
6766       /* Make sure INPUT_FILE_NUMBER points to first available open
6767          slot.  */
6768       input_file_number = n_infiles;
6769       if (lang_specific_pre_link ())
6770         error_count++;
6771     }
6772
6773   /* Determine if there are any linker input files.  */
6774   num_linker_inputs = 0;
6775   for (i = 0; (int) i < n_infiles; i++)
6776     if (explicit_link_files[i] || outfiles[i] != NULL)
6777       num_linker_inputs++;
6778
6779   /* Run ld to link all the compiler output files.  */
6780
6781   if (num_linker_inputs > 0 && error_count == 0)
6782     {
6783       int tmp = execution_count;
6784
6785       /* We'll use ld if we can't find collect2.  */
6786       if (! strcmp (linker_name_spec, "collect2"))
6787         {
6788           char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
6789           if (s == NULL)
6790             linker_name_spec = "ld";
6791         }
6792       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6793          for collect.  */
6794       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
6795       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
6796
6797       value = do_spec (link_command_spec);
6798       if (value < 0)
6799         error_count = 1;
6800       linker_was_run = (tmp != execution_count);
6801     }
6802
6803   /* If options said don't run linker,
6804      complain about input files to be given to the linker.  */
6805
6806   if (! linker_was_run && error_count == 0)
6807     for (i = 0; (int) i < n_infiles; i++)
6808       if (explicit_link_files[i])
6809         error ("%s: linker input file unused because linking not done",
6810                outfiles[i]);
6811
6812   /* Delete some or all of the temporary files we made.  */
6813
6814   if (error_count)
6815     delete_failure_queue ();
6816   delete_temp_files ();
6817
6818   if (print_help_list)
6819     {
6820       printf (("\nFor bug reporting instructions, please see:\n"));
6821       printf ("%s\n", bug_report_url);
6822     }
6823
6824   return (signal_count != 0 ? 2
6825           : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6826           : 0);
6827 }
6828
6829 /* Find the proper compilation spec for the file name NAME,
6830    whose length is LENGTH.  LANGUAGE is the specified language,
6831    or 0 if this file is to be passed to the linker.  */
6832
6833 static struct compiler *
6834 lookup_compiler (const char *name, size_t length, const char *language)
6835 {
6836   struct compiler *cp;
6837
6838   /* If this was specified by the user to be a linker input, indicate that.  */
6839   if (language != 0 && language[0] == '*')
6840     return 0;
6841
6842   /* Otherwise, look for the language, if one is spec'd.  */
6843   if (language != 0)
6844     {
6845       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6846         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6847           return cp;
6848
6849       error ("language %s not recognized", language);
6850       return 0;
6851     }
6852
6853   /* Look for a suffix.  */
6854   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6855     {
6856       if (/* The suffix `-' matches only the file name `-'.  */
6857           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6858           || (strlen (cp->suffix) < length
6859               /* See if the suffix matches the end of NAME.  */
6860               && !strcmp (cp->suffix,
6861                           name + length - strlen (cp->suffix))
6862          ))
6863         break;
6864     }
6865
6866 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6867   /* Look again, but case-insensitively this time.  */
6868   if (cp < compilers)
6869     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6870       {
6871         if (/* The suffix `-' matches only the file name `-'.  */
6872             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6873             || (strlen (cp->suffix) < length
6874                 /* See if the suffix matches the end of NAME.  */
6875                 && ((!strcmp (cp->suffix,
6876                              name + length - strlen (cp->suffix))
6877                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6878                     && !strcasecmp (cp->suffix,
6879                                     name + length - strlen (cp->suffix)))
6880            ))
6881           break;
6882       }
6883 #endif
6884
6885   if (cp >= compilers)
6886     {
6887       if (cp->spec[0] != '@')
6888         /* A non-alias entry: return it.  */
6889         return cp;
6890
6891       /* An alias entry maps a suffix to a language.
6892          Search for the language; pass 0 for NAME and LENGTH
6893          to avoid infinite recursion if language not found.  */
6894       return lookup_compiler (NULL, 0, cp->spec + 1);
6895     }
6896   return 0;
6897 }
6898 \f
6899 static char *
6900 save_string (const char *s, int len)
6901 {
6902   char *result = XNEWVEC (char, len + 1);
6903
6904   memcpy (result, s, len);
6905   result[len] = 0;
6906   return result;
6907 }
6908
6909 void
6910 pfatal_with_name (const char *name)
6911 {
6912   perror_with_name (name);
6913   delete_temp_files ();
6914   exit (1);
6915 }
6916
6917 static void
6918 perror_with_name (const char *name)
6919 {
6920   error ("%s: %s", name, xstrerror (errno));
6921 }
6922
6923 /* Output an error message and exit.  */
6924
6925 void
6926 fancy_abort (const char *file, int line, const char *func)
6927 {
6928   fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
6929 }
6930 \f
6931 /* Output an error message and exit.  */
6932
6933 void
6934 fatal_ice (const char *cmsgid, ...)
6935 {
6936   va_list ap;
6937
6938   va_start (ap, cmsgid);
6939
6940   fprintf (stderr, "%s: ", programname);
6941   vfprintf (stderr, _(cmsgid), ap);
6942   va_end (ap);
6943   fprintf (stderr, "\n");
6944   delete_temp_files ();
6945   exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
6946 }
6947
6948 void
6949 fatal (const char *cmsgid, ...)
6950 {
6951   va_list ap;
6952
6953   va_start (ap, cmsgid);
6954
6955   fprintf (stderr, "%s: ", programname);
6956   vfprintf (stderr, _(cmsgid), ap);
6957   va_end (ap);
6958   fprintf (stderr, "\n");
6959   delete_temp_files ();
6960   exit (1);
6961 }
6962
6963 /* The argument is actually c-format, not gcc-internal-format,
6964    but because functions with identical names are used through
6965    the rest of the compiler with gcc-internal-format, we just
6966    need to hope all users of these functions use the common
6967    subset between c-format and gcc-internal-format.  */
6968
6969 void
6970 error (const char *gmsgid, ...)
6971 {
6972   va_list ap;
6973
6974   va_start (ap, gmsgid);
6975   fprintf (stderr, "%s: ", programname);
6976   vfprintf (stderr, _(gmsgid), ap);
6977   va_end (ap);
6978
6979   fprintf (stderr, "\n");
6980 }
6981
6982 static void
6983 notice (const char *cmsgid, ...)
6984 {
6985   va_list ap;
6986
6987   va_start (ap, cmsgid);
6988   vfprintf (stderr, _(cmsgid), ap);
6989   va_end (ap);
6990 }
6991 \f
6992 static inline void
6993 validate_switches_from_spec (const char *spec)
6994 {
6995   const char *p = spec;
6996   char c;
6997   while ((c = *p++))
6998     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6999       /* We have a switch spec.  */
7000       p = validate_switches (p + 1);
7001 }
7002
7003 static void
7004 validate_all_switches (void)
7005 {
7006   struct compiler *comp;
7007   struct spec_list *spec;
7008
7009   for (comp = compilers; comp->spec; comp++)
7010     validate_switches_from_spec (comp->spec);
7011
7012   /* Look through the linked list of specs read from the specs file.  */
7013   for (spec = specs; spec; spec = spec->next)
7014     validate_switches_from_spec (*spec->ptr_spec);
7015
7016   validate_switches_from_spec (link_command_spec);
7017 }
7018
7019 /* Look at the switch-name that comes after START
7020    and mark as valid all supplied switches that match it.  */
7021
7022 static const char *
7023 validate_switches (const char *start)
7024 {
7025   const char *p = start;
7026   const char *atom;
7027   size_t len;
7028   int i;
7029   bool suffix = false;
7030   bool starred = false;
7031
7032 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7033
7034 next_member:
7035   SKIP_WHITE ();
7036
7037   if (*p == '!')
7038     p++;
7039
7040   SKIP_WHITE ();
7041   if (*p == '.')
7042     suffix = true, p++;
7043
7044   atom = p;
7045   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7046          || *p == ',' || *p == '.' || *p == '@')
7047     p++;
7048   len = p - atom;
7049
7050   if (*p == '*')
7051     starred = true, p++;
7052
7053   SKIP_WHITE ();
7054
7055   if (!suffix)
7056     {
7057       /* Mark all matching switches as valid.  */
7058       for (i = 0; i < n_switches; i++)
7059         if (!strncmp (switches[i].part1, atom, len)
7060             && (starred || switches[i].part1[len] == 0))
7061           switches[i].validated = 1;
7062     }
7063
7064   if (*p) p++;
7065   if (*p && (p[-1] == '|' || p[-1] == '&'))
7066     goto next_member;
7067
7068   if (*p && p[-1] == ':')
7069     {
7070       while (*p && *p != ';' && *p != '}')
7071         {
7072           if (*p == '%')
7073             {
7074               p++;
7075               if (*p == '{' || *p == '<')
7076                 p = validate_switches (p+1);
7077               else if (p[0] == 'W' && p[1] == '{')
7078                 p = validate_switches (p+2);
7079             }
7080           else
7081             p++;
7082         }
7083
7084       if (*p) p++;
7085       if (*p && p[-1] == ';')
7086         goto next_member;
7087     }
7088
7089   return p;
7090 #undef SKIP_WHITE
7091 }
7092 \f
7093 struct mdswitchstr
7094 {
7095   const char *str;
7096   int len;
7097 };
7098
7099 static struct mdswitchstr *mdswitches;
7100 static int n_mdswitches;
7101
7102 /* Check whether a particular argument was used.  The first time we
7103    canonicalize the switches to keep only the ones we care about.  */
7104
7105 static int
7106 used_arg (const char *p, int len)
7107 {
7108   struct mswitchstr
7109   {
7110     const char *str;
7111     const char *replace;
7112     int len;
7113     int rep_len;
7114   };
7115
7116   static struct mswitchstr *mswitches;
7117   static int n_mswitches;
7118   int i, j;
7119
7120   if (!mswitches)
7121     {
7122       struct mswitchstr *matches;
7123       const char *q;
7124       int cnt = 0;
7125
7126       /* Break multilib_matches into the component strings of string
7127          and replacement string.  */
7128       for (q = multilib_matches; *q != '\0'; q++)
7129         if (*q == ';')
7130           cnt++;
7131
7132       matches = alloca ((sizeof (struct mswitchstr)) * cnt);
7133       i = 0;
7134       q = multilib_matches;
7135       while (*q != '\0')
7136         {
7137           matches[i].str = q;
7138           while (*q != ' ')
7139             {
7140               if (*q == '\0')
7141                 {
7142                 invalid_matches:
7143                   fatal ("multilib spec '%s' is invalid", multilib_matches);
7144                 }
7145               q++;
7146             }
7147           matches[i].len = q - matches[i].str;
7148
7149           matches[i].replace = ++q;
7150           while (*q != ';' && *q != '\0')
7151             {
7152               if (*q == ' ')
7153                 goto invalid_matches;
7154               q++;
7155             }
7156           matches[i].rep_len = q - matches[i].replace;
7157           i++;
7158           if (*q == ';')
7159             q++;
7160         }
7161
7162       /* Now build a list of the replacement string for switches that we care
7163          about.  Make sure we allocate at least one entry.  This prevents
7164          xmalloc from calling fatal, and prevents us from re-executing this
7165          block of code.  */
7166       mswitches
7167         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7168       for (i = 0; i < n_switches; i++)
7169         if (switches[i].live_cond != SWITCH_IGNORE)
7170           {
7171             int xlen = strlen (switches[i].part1);
7172             for (j = 0; j < cnt; j++)
7173               if (xlen == matches[j].len
7174                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7175                 {
7176                   mswitches[n_mswitches].str = matches[j].replace;
7177                   mswitches[n_mswitches].len = matches[j].rep_len;
7178                   mswitches[n_mswitches].replace = (char *) 0;
7179                   mswitches[n_mswitches].rep_len = 0;
7180                   n_mswitches++;
7181                   break;
7182                 }
7183           }
7184
7185       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7186          on the command line nor any options mutually incompatible with
7187          them.  */
7188       for (i = 0; i < n_mdswitches; i++)
7189         {
7190           const char *r;
7191
7192           for (q = multilib_options; *q != '\0'; q++)
7193             {
7194               while (*q == ' ')
7195                 q++;
7196
7197               r = q;
7198               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7199                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7200                 {
7201                   while (*q != ' ' && *q != '/' && *q != '\0')
7202                     q++;
7203                   if (*q != '/')
7204                     break;
7205                   q++;
7206                 }
7207
7208               if (*q != ' ' && *q != '\0')
7209                 {
7210                   while (*r != ' ' && *r != '\0')
7211                     {
7212                       q = r;
7213                       while (*q != ' ' && *q != '/' && *q != '\0')
7214                         q++;
7215
7216                       if (used_arg (r, q - r))
7217                         break;
7218
7219                       if (*q != '/')
7220                         {
7221                           mswitches[n_mswitches].str = mdswitches[i].str;
7222                           mswitches[n_mswitches].len = mdswitches[i].len;
7223                           mswitches[n_mswitches].replace = (char *) 0;
7224                           mswitches[n_mswitches].rep_len = 0;
7225                           n_mswitches++;
7226                           break;
7227                         }
7228
7229                       r = q + 1;
7230                     }
7231                   break;
7232                 }
7233             }
7234         }
7235     }
7236
7237   for (i = 0; i < n_mswitches; i++)
7238     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7239       return 1;
7240
7241   return 0;
7242 }
7243
7244 static int
7245 default_arg (const char *p, int len)
7246 {
7247   int i;
7248
7249   for (i = 0; i < n_mdswitches; i++)
7250     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7251       return 1;
7252
7253   return 0;
7254 }
7255
7256 /* Work out the subdirectory to use based on the options. The format of
7257    multilib_select is a list of elements. Each element is a subdirectory
7258    name followed by a list of options followed by a semicolon. The format
7259    of multilib_exclusions is the same, but without the preceding
7260    directory. First gcc will check the exclusions, if none of the options
7261    beginning with an exclamation point are present, and all of the other
7262    options are present, then we will ignore this completely. Passing
7263    that, gcc will consider each multilib_select in turn using the same
7264    rules for matching the options. If a match is found, that subdirectory
7265    will be used.  */
7266
7267 static void
7268 set_multilib_dir (void)
7269 {
7270   const char *p;
7271   unsigned int this_path_len;
7272   const char *this_path, *this_arg;
7273   const char *start, *end;
7274   int not_arg;
7275   int ok, ndfltok, first;
7276
7277   n_mdswitches = 0;
7278   start = multilib_defaults;
7279   while (*start == ' ' || *start == '\t')
7280     start++;
7281   while (*start != '\0')
7282     {
7283       n_mdswitches++;
7284       while (*start != ' ' && *start != '\t' && *start != '\0')
7285         start++;
7286       while (*start == ' ' || *start == '\t')
7287         start++;
7288     }
7289
7290   if (n_mdswitches)
7291     {
7292       int i = 0;
7293
7294       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7295       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7296         {
7297           while (*start == ' ' || *start == '\t')
7298             start++;
7299
7300           if (*start == '\0')
7301             break;
7302
7303           for (end = start + 1;
7304                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7305             ;
7306
7307           obstack_grow (&multilib_obstack, start, end - start);
7308           obstack_1grow (&multilib_obstack, 0);
7309           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7310           mdswitches[i++].len = end - start;
7311
7312           if (*end == '\0')
7313             break;
7314         }
7315     }
7316
7317   p = multilib_exclusions;
7318   while (*p != '\0')
7319     {
7320       /* Ignore newlines.  */
7321       if (*p == '\n')
7322         {
7323           ++p;
7324           continue;
7325         }
7326
7327       /* Check the arguments.  */
7328       ok = 1;
7329       while (*p != ';')
7330         {
7331           if (*p == '\0')
7332             {
7333             invalid_exclusions:
7334               fatal ("multilib exclusions '%s' is invalid",
7335                      multilib_exclusions);
7336             }
7337
7338           if (! ok)
7339             {
7340               ++p;
7341               continue;
7342             }
7343
7344           this_arg = p;
7345           while (*p != ' ' && *p != ';')
7346             {
7347               if (*p == '\0')
7348                 goto invalid_exclusions;
7349               ++p;
7350             }
7351
7352           if (*this_arg != '!')
7353             not_arg = 0;
7354           else
7355             {
7356               not_arg = 1;
7357               ++this_arg;
7358             }
7359
7360           ok = used_arg (this_arg, p - this_arg);
7361           if (not_arg)
7362             ok = ! ok;
7363
7364           if (*p == ' ')
7365             ++p;
7366         }
7367
7368       if (ok)
7369         return;
7370
7371       ++p;
7372     }
7373
7374   first = 1;
7375   p = multilib_select;
7376   while (*p != '\0')
7377     {
7378       /* Ignore newlines.  */
7379       if (*p == '\n')
7380         {
7381           ++p;
7382           continue;
7383         }
7384
7385       /* Get the initial path.  */
7386       this_path = p;
7387       while (*p != ' ')
7388         {
7389           if (*p == '\0')
7390             {
7391             invalid_select:
7392               fatal ("multilib select '%s' is invalid",
7393                      multilib_select);
7394             }
7395           ++p;
7396         }
7397       this_path_len = p - this_path;
7398
7399       /* Check the arguments.  */
7400       ok = 1;
7401       ndfltok = 1;
7402       ++p;
7403       while (*p != ';')
7404         {
7405           if (*p == '\0')
7406             goto invalid_select;
7407
7408           if (! ok)
7409             {
7410               ++p;
7411               continue;
7412             }
7413
7414           this_arg = p;
7415           while (*p != ' ' && *p != ';')
7416             {
7417               if (*p == '\0')
7418                 goto invalid_select;
7419               ++p;
7420             }
7421
7422           if (*this_arg != '!')
7423             not_arg = 0;
7424           else
7425             {
7426               not_arg = 1;
7427               ++this_arg;
7428             }
7429
7430           /* If this is a default argument, we can just ignore it.
7431              This is true even if this_arg begins with '!'.  Beginning
7432              with '!' does not mean that this argument is necessarily
7433              inappropriate for this library: it merely means that
7434              there is a more specific library which uses this
7435              argument.  If this argument is a default, we need not
7436              consider that more specific library.  */
7437           ok = used_arg (this_arg, p - this_arg);
7438           if (not_arg)
7439             ok = ! ok;
7440
7441           if (! ok)
7442             ndfltok = 0;
7443
7444           if (default_arg (this_arg, p - this_arg))
7445             ok = 1;
7446
7447           if (*p == ' ')
7448             ++p;
7449         }
7450
7451       if (ok && first)
7452         {
7453           if (this_path_len != 1
7454               || this_path[0] != '.')
7455             {
7456               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7457               char *q;
7458
7459               strncpy (new_multilib_dir, this_path, this_path_len);
7460               new_multilib_dir[this_path_len] = '\0';
7461               q = strchr (new_multilib_dir, ':');
7462               if (q != NULL)
7463                 *q = '\0';
7464               multilib_dir = new_multilib_dir;
7465             }
7466           first = 0;
7467         }
7468
7469       if (ndfltok)
7470         {
7471           const char *q = this_path, *end = this_path + this_path_len;
7472
7473           while (q < end && *q != ':')
7474             q++;
7475           if (q < end)
7476             {
7477               char *new_multilib_os_dir = XNEWVEC (char, end - q);
7478               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7479               new_multilib_os_dir[end - q - 1] = '\0';
7480               multilib_os_dir = new_multilib_os_dir;
7481               break;
7482             }
7483         }
7484
7485       ++p;
7486     }
7487
7488   if (multilib_dir == NULL && multilib_os_dir != NULL
7489       && strcmp (multilib_os_dir, ".") == 0)
7490     {
7491       free ((char *) multilib_os_dir);
7492       multilib_os_dir = NULL;
7493     }
7494   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7495     multilib_os_dir = multilib_dir;
7496 }
7497
7498 /* Print out the multiple library subdirectory selection
7499    information.  This prints out a series of lines.  Each line looks
7500    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7501    required.  Only the desired options are printed out, the negative
7502    matches.  The options are print without a leading dash.  There are
7503    no spaces to make it easy to use the information in the shell.
7504    Each subdirectory is printed only once.  This assumes the ordering
7505    generated by the genmultilib script. Also, we leave out ones that match
7506    the exclusions.  */
7507
7508 static void
7509 print_multilib_info (void)
7510 {
7511   const char *p = multilib_select;
7512   const char *last_path = 0, *this_path;
7513   int skip;
7514   unsigned int last_path_len = 0;
7515
7516   while (*p != '\0')
7517     {
7518       skip = 0;
7519       /* Ignore newlines.  */
7520       if (*p == '\n')
7521         {
7522           ++p;
7523           continue;
7524         }
7525
7526       /* Get the initial path.  */
7527       this_path = p;
7528       while (*p != ' ')
7529         {
7530           if (*p == '\0')
7531             {
7532             invalid_select:
7533               fatal ("multilib select '%s' is invalid", multilib_select);
7534             }
7535
7536           ++p;
7537         }
7538
7539       /* When --disable-multilib was used but target defines
7540          MULTILIB_OSDIRNAMES, entries starting with .: are there just
7541          to find multilib_os_dir, so skip them from output.  */
7542       if (this_path[0] == '.' && this_path[1] == ':')
7543         skip = 1;
7544
7545       /* Check for matches with the multilib_exclusions. We don't bother
7546          with the '!' in either list. If any of the exclusion rules match
7547          all of its options with the select rule, we skip it.  */
7548       {
7549         const char *e = multilib_exclusions;
7550         const char *this_arg;
7551
7552         while (*e != '\0')
7553           {
7554             int m = 1;
7555             /* Ignore newlines.  */
7556             if (*e == '\n')
7557               {
7558                 ++e;
7559                 continue;
7560               }
7561
7562             /* Check the arguments.  */
7563             while (*e != ';')
7564               {
7565                 const char *q;
7566                 int mp = 0;
7567
7568                 if (*e == '\0')
7569                   {
7570                   invalid_exclusion:
7571                     fatal ("multilib exclusion '%s' is invalid",
7572                            multilib_exclusions);
7573                   }
7574
7575                 if (! m)
7576                   {
7577                     ++e;
7578                     continue;
7579                   }
7580
7581                 this_arg = e;
7582
7583                 while (*e != ' ' && *e != ';')
7584                   {
7585                     if (*e == '\0')
7586                       goto invalid_exclusion;
7587                     ++e;
7588                   }
7589
7590                 q = p + 1;
7591                 while (*q != ';')
7592                   {
7593                     const char *arg;
7594                     int len = e - this_arg;
7595
7596                     if (*q == '\0')
7597                       goto invalid_select;
7598
7599                     arg = q;
7600
7601                     while (*q != ' ' && *q != ';')
7602                       {
7603                         if (*q == '\0')
7604                           goto invalid_select;
7605                         ++q;
7606                       }
7607
7608                     if (! strncmp (arg, this_arg,
7609                                    (len < q - arg) ? q - arg : len)
7610                         || default_arg (this_arg, e - this_arg))
7611                       {
7612                         mp = 1;
7613                         break;
7614                       }
7615
7616                     if (*q == ' ')
7617                       ++q;
7618                   }
7619
7620                 if (! mp)
7621                   m = 0;
7622
7623                 if (*e == ' ')
7624                   ++e;
7625               }
7626
7627             if (m)
7628               {
7629                 skip = 1;
7630                 break;
7631               }
7632
7633             if (*e != '\0')
7634               ++e;
7635           }
7636       }
7637
7638       if (! skip)
7639         {
7640           /* If this is a duplicate, skip it.  */
7641           skip = (last_path != 0
7642                   && (unsigned int) (p - this_path) == last_path_len
7643                   && ! strncmp (last_path, this_path, last_path_len));
7644
7645           last_path = this_path;
7646           last_path_len = p - this_path;
7647         }
7648
7649       /* If this directory requires any default arguments, we can skip
7650          it.  We will already have printed a directory identical to
7651          this one which does not require that default argument.  */
7652       if (! skip)
7653         {
7654           const char *q;
7655
7656           q = p + 1;
7657           while (*q != ';')
7658             {
7659               const char *arg;
7660
7661               if (*q == '\0')
7662                 goto invalid_select;
7663
7664               if (*q == '!')
7665                 arg = NULL;
7666               else
7667                 arg = q;
7668
7669               while (*q != ' ' && *q != ';')
7670                 {
7671                   if (*q == '\0')
7672                     goto invalid_select;
7673                   ++q;
7674                 }
7675
7676               if (arg != NULL
7677                   && default_arg (arg, q - arg))
7678                 {
7679                   skip = 1;
7680                   break;
7681                 }
7682
7683               if (*q == ' ')
7684                 ++q;
7685             }
7686         }
7687
7688       if (! skip)
7689         {
7690           const char *p1;
7691
7692           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7693             putchar (*p1);
7694           putchar (';');
7695         }
7696
7697       ++p;
7698       while (*p != ';')
7699         {
7700           int use_arg;
7701
7702           if (*p == '\0')
7703             goto invalid_select;
7704
7705           if (skip)
7706             {
7707               ++p;
7708               continue;
7709             }
7710
7711           use_arg = *p != '!';
7712
7713           if (use_arg)
7714             putchar ('@');
7715
7716           while (*p != ' ' && *p != ';')
7717             {
7718               if (*p == '\0')
7719                 goto invalid_select;
7720               if (use_arg)
7721                 putchar (*p);
7722               ++p;
7723             }
7724
7725           if (*p == ' ')
7726             ++p;
7727         }
7728
7729       if (! skip)
7730         {
7731           /* If there are extra options, print them now.  */
7732           if (multilib_extra && *multilib_extra)
7733             {
7734               int print_at = TRUE;
7735               const char *q;
7736
7737               for (q = multilib_extra; *q != '\0'; q++)
7738                 {
7739                   if (*q == ' ')
7740                     print_at = TRUE;
7741                   else
7742                     {
7743                       if (print_at)
7744                         putchar ('@');
7745                       putchar (*q);
7746                       print_at = FALSE;
7747                     }
7748                 }
7749             }
7750
7751           putchar ('\n');
7752         }
7753
7754       ++p;
7755     }
7756 }
7757 \f
7758 /* if-exists built-in spec function.
7759
7760    Checks to see if the file specified by the absolute pathname in
7761    ARGS exists.  Returns that pathname if found.
7762
7763    The usual use for this function is to check for a library file
7764    (whose name has been expanded with %s).  */
7765
7766 static const char *
7767 if_exists_spec_function (int argc, const char **argv)
7768 {
7769   /* Must have only one argument.  */
7770   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7771     return argv[0];
7772
7773   return NULL;
7774 }
7775
7776 /* if-exists-else built-in spec function.
7777
7778    This is like if-exists, but takes an additional argument which
7779    is returned if the first argument does not exist.  */
7780
7781 static const char *
7782 if_exists_else_spec_function (int argc, const char **argv)
7783 {
7784   /* Must have exactly two arguments.  */
7785   if (argc != 2)
7786     return NULL;
7787
7788   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7789     return argv[0];
7790
7791   return argv[1];
7792 }
7793
7794 /* replace-outfile built-in spec function.
7795
7796    This looks for the first argument in the outfiles array's name and
7797    replaces it with the second argument.  */
7798
7799 static const char *
7800 replace_outfile_spec_function (int argc, const char **argv)
7801 {
7802   int i;
7803   /* Must have exactly two arguments.  */
7804   if (argc != 2)
7805     abort ();
7806
7807   for (i = 0; i < n_infiles; i++)
7808     {
7809       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
7810         outfiles[i] = xstrdup (argv[1]);
7811     }
7812   return NULL;
7813 }
7814
7815 /* Given two version numbers, compares the two numbers.
7816    A version number must match the regular expression
7817    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7818 */
7819 static int
7820 compare_version_strings (const char *v1, const char *v2)
7821 {
7822   int rresult;
7823   regex_t r;
7824
7825   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7826                REG_EXTENDED | REG_NOSUB) != 0)
7827     abort ();
7828   rresult = regexec (&r, v1, 0, NULL, 0);
7829   if (rresult == REG_NOMATCH)
7830     fatal ("invalid version number `%s'", v1);
7831   else if (rresult != 0)
7832     abort ();
7833   rresult = regexec (&r, v2, 0, NULL, 0);
7834   if (rresult == REG_NOMATCH)
7835     fatal ("invalid version number `%s'", v2);
7836   else if (rresult != 0)
7837     abort ();
7838
7839   return strverscmp (v1, v2);
7840 }
7841
7842
7843 /* version_compare built-in spec function.
7844
7845    This takes an argument of the following form:
7846
7847    <comparison-op> <arg1> [<arg2>] <switch> <result>
7848
7849    and produces "result" if the comparison evaluates to true,
7850    and nothing if it doesn't.
7851
7852    The supported <comparison-op> values are:
7853
7854    >=  true if switch is a later (or same) version than arg1
7855    !>  opposite of >=
7856    <   true if switch is an earlier version than arg1
7857    !<  opposite of <
7858    ><  true if switch is arg1 or later, and earlier than arg2
7859    <>  true if switch is earlier than arg1 or is arg2 or later
7860
7861    If the switch is not present, the condition is false unless
7862    the first character of the <comparison-op> is '!'.
7863
7864    For example,
7865    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7866    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
7867
7868 static const char *
7869 version_compare_spec_function (int argc, const char **argv)
7870 {
7871   int comp1, comp2;
7872   size_t switch_len;
7873   const char *switch_value = NULL;
7874   int nargs = 1, i;
7875   bool result;
7876
7877   if (argc < 3)
7878     fatal ("too few arguments to %%:version-compare");
7879   if (argv[0][0] == '\0')
7880     abort ();
7881   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
7882     nargs = 2;
7883   if (argc != nargs + 3)
7884     fatal ("too many arguments to %%:version-compare");
7885
7886   switch_len = strlen (argv[nargs + 1]);
7887   for (i = 0; i < n_switches; i++)
7888     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
7889         && check_live_switch (i, switch_len))
7890       switch_value = switches[i].part1 + switch_len;
7891
7892   if (switch_value == NULL)
7893     comp1 = comp2 = -1;
7894   else
7895     {
7896       comp1 = compare_version_strings (switch_value, argv[1]);
7897       if (nargs == 2)
7898         comp2 = compare_version_strings (switch_value, argv[2]);
7899       else
7900         comp2 = -1;  /* This value unused.  */
7901     }
7902
7903   switch (argv[0][0] << 8 | argv[0][1])
7904     {
7905     case '>' << 8 | '=':
7906       result = comp1 >= 0;
7907       break;
7908     case '!' << 8 | '<':
7909       result = comp1 >= 0 || switch_value == NULL;
7910       break;
7911     case '<' << 8:
7912       result = comp1 < 0;
7913       break;
7914     case '!' << 8 | '>':
7915       result = comp1 < 0 || switch_value == NULL;
7916       break;
7917     case '>' << 8 | '<':
7918       result = comp1 >= 0 && comp2 < 0;
7919       break;
7920     case '<' << 8 | '>':
7921       result = comp1 < 0 || comp2 >= 0;
7922       break;
7923
7924     default:
7925       fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
7926     }
7927   if (! result)
7928     return NULL;
7929
7930   return argv[nargs + 2];
7931 }
7932
7933 /* %:include builtin spec function.  This differs from %include in that it
7934    can be nested inside a spec, and thus be conditionalized.  It takes
7935    one argument, the filename, and looks for it in the startfile path.
7936    The result is always NULL, i.e. an empty expansion.  */
7937
7938 static const char *
7939 include_spec_function (int argc, const char **argv)
7940 {
7941   char *file;
7942
7943   if (argc != 1)
7944     abort ();
7945
7946   file = find_a_file (&startfile_prefixes, argv[0], R_OK, 0);
7947   read_specs (file ? file : argv[0], FALSE);
7948
7949   return NULL;
7950 }