gcc/gcc.c

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