gcc/gcc.c

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