gcc/gcc.c

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