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