gcc/gcc.c

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