gcc/gcc.c

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