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