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