gcc/gcc.c

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