gcc/gcc.c

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