gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 This paragraph is here to try to keep Sun CC from dying.
  21 The number of chars here seems crucial!!!!  */
  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 \f
  33 #include <sys/types.h>
  34 #include <ctype.h>
  35 #include <signal.h>
  36 #include <sys/stat.h>
  37 #include <sys/file.h>   /* May get R_OK, etc. on some systems.  */
  38 #include <errno.h>
  39
  40 #include "config.h"
  41 #include "obstack.h"
  42 #ifdef __STDC__
  43 #include <stdarg.h>
  44 #else
  45 #include <varargs.h>
  46 #endif
  47 #include <stdio.h>
  48
  49 /* Include multi-lib information.  */
  50 #include "multilib.h"
  51
  52 #ifndef R_OK
  53 #define R_OK 4
  54 #define W_OK 2
  55 #define X_OK 1
  56 #endif
  57
  58 /* Add prototype support.  */
  59 #ifndef PROTO
  60 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
  61 #define PROTO(ARGS) ARGS
  62 #else
  63 #define PROTO(ARGS) ()
  64 #endif
  65 #endif
  66
  67 #ifndef VPROTO
  68 #ifdef __STDC__
  69 #define PVPROTO(ARGS)           ARGS
  70 #define VPROTO(ARGS)            ARGS
  71 #define VA_START(va_list,var)   va_start(va_list,var)
  72 #else
  73 #define PVPROTO(ARGS)           ()
  74 #define VPROTO(ARGS)            (va_alist) va_dcl
  75 #define VA_START(va_list,var)   va_start(va_list)
  76 #endif
  77 #endif
  78
  79 /* Define a generic NULL if one hasn't already been defined.  */
  80
  81 #ifndef NULL
  82 #define NULL 0
  83 #endif
  84
  85 #ifndef GENERIC_PTR
  86 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
  87 #define GENERIC_PTR void *
  88 #else
  89 #define GENERIC_PTR char *
  90 #endif
  91 #endif
  92
  93 #ifndef NULL_PTR
  94 #define NULL_PTR ((GENERIC_PTR)0)
  95 #endif
  96
  97 #ifdef USG
  98 #define vfork fork
  99 #endif /* USG */
 100
 101 /* On MSDOS, write temp files in current dir
 102    because there's no place else we can expect to use.  */
 103 #ifdef __MSDOS__
 104 #ifndef P_tmpdir
 105 #define P_tmpdir "."
 106 #endif
 107 #endif
 108
 109 /* Test if something is a normal file.  */
 110 #ifndef S_ISREG
 111 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 112 #endif
 113
 114 /* Test if something is a directory.  */
 115 #ifndef S_ISDIR
 116 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 117 #endif
 118
 119 /* By default there is no special suffix for executables.  */
 120 #ifndef EXECUTABLE_SUFFIX
 121 #define EXECUTABLE_SUFFIX ""
 122 #endif
 123
 124 /* By default, colon separates directories in a path.  */
 125 #ifndef PATH_SEPARATOR
 126 #define PATH_SEPARATOR ':'
 127 #endif
 128
 129 #define obstack_chunk_alloc xmalloc
 130 #define obstack_chunk_free free
 131
 132 extern void free ();
 133 extern char *getenv ();
 134
 135 #ifndef errno
 136 extern int errno;
 137 #endif
 138
 139 extern int sys_nerr;
 140 #if defined(bsd4_4) || defined(__NetBSD__)
 141 extern const char *const sys_errlist[];
 142 #else
 143 extern char *sys_errlist[];
 144 #endif
 145
 146 extern int execv (), execvp ();
 147
 148 /* If a stage of compilation returns an exit status >= 1,
 149    compilation of that file ceases.  */
 150
 151 #define MIN_FATAL_STATUS 1
 152
 153 /* Flag saying to print the full filename of this file
 154    as found through our usual search mechanism.  */
 155
 156 static char *print_file_name = NULL;
 157
 158 /* As print_file_name, but search for executable file. */
 159
 160 static char *print_prog_name = NULL;
 161
 162 /* Flag saying to print the relative path we'd use to
 163    find libgcc.a given the current compiler flags.  */
 164
 165 static int print_multi_directory;
 166
 167 /* Flag saying to print the list of subdirectories and
 168    compiler flags used to select them in a standard form.  */
 169
 170 static int print_multi_lib;
 171
 172 /* Flag indicating whether we should print the command and arguments */
 173
 174 static int verbose_flag;
 175
 176 /* Nonzero means write "temp" files in source directory
 177    and use the source file's name in them, and don't delete them.  */
 178
 179 static int save_temps_flag;
 180
 181 /* The compiler version.  */
 182
 183 static char *compiler_version;
 184
 185 /* The target version specified with -V */
 186
 187 static char *spec_version = DEFAULT_TARGET_VERSION;
 188
 189 /* The target machine specified with -b.  */
 190
 191 static char *spec_machine = DEFAULT_TARGET_MACHINE;
 192
 193 /* Nonzero if cross-compiling.
 194    When -b is used, the value comes from the `specs' file.  */
 195
 196 #ifdef CROSS_COMPILE
 197 static int cross_compile = 1;
 198 #else
 199 static int cross_compile = 0;
 200 #endif
 201
 202 /* The number of errors that have occurred; the link phase will not be
 203    run if this is non-zero.  */
 204 static int error_count = 0;
 205
 206 /* This is the obstack which we use to allocate many strings.  */
 207
 208 static struct obstack obstack;
 209
 210 /* This is the obstack to build an environment variable to pass to
 211    collect2 that describes all of the relevant switches of what to
 212    pass the compiler in building the list of pointers to constructors
 213    and destructors.  */
 214
 215 static struct obstack collect_obstack;
 216
 217 extern char *version_string;
 218
 219 /* Forward declaration for prototypes.  */
 220 struct path_prefix;
 221
 222 static void set_spec            PROTO((char *, char *));
 223 static struct compiler *lookup_compiler PROTO((char *, int, char *));
 224 static char *find_a_file        PROTO((struct path_prefix *, char *, int));
 225 static void add_prefix          PROTO((struct path_prefix *, char *, int, int, int *));
 226 static char *skip_whitespace    PROTO((char *));
 227 static void record_temp_file    PROTO((char *, int, int));
 228 static void delete_if_ordinary  PROTO((char *));
 229 static void delete_temp_files   PROTO((void));
 230 static void delete_failure_queue PROTO((void));
 231 static void clear_failure_queue PROTO((void));
 232 static char *choose_temp_base_try PROTO((char *, char *));
 233 static void choose_temp_base    PROTO((void));
 234 static int check_live_switch    PROTO((int, int));
 235 static char *handle_braces      PROTO((char *));
 236 static char *save_string        PROTO((char *, int));
 237 static char *concat             PROTO((char *, char *, char *));
 238 static int do_spec              PROTO((char *));
 239 static int do_spec_1            PROTO((char *, int, char *));
 240 static char *find_file          PROTO((char *));
 241 static int is_directory         PROTO((char *, char *, int));
 242 static void validate_switches   PROTO((char *));
 243 static void validate_all_switches PROTO((void));
 244 static void give_switch         PROTO((int, int));
 245 static int used_arg             PROTO((char *, int));
 246 static void set_multilib_dir    PROTO((void));
 247 static void print_multilib_info PROTO((void));
 248 static void pfatal_with_name    PROTO((char *));
 249 static void perror_with_name    PROTO((char *));
 250 static void perror_exec         PROTO((char *));
 251 #ifdef HAVE_VPRINTF
 252 static void fatal               PVPROTO((char *, ...));
 253 static void error               PVPROTO((char *, ...));
 254 #else
 255 /* We must not provide any prototype here, even if ANSI C.  */
 256 static void fatal               PROTO(());
 257 static void error               PROTO(());
 258 #endif
 259
 260 void fancy_abort ();
 261 char *xmalloc ();
 262 char *xrealloc ();
 263 \f
 264 /* Specs are strings containing lines, each of which (if not blank)
 265 is made up of a program name, and arguments separated by spaces.
 266 The program name must be exact and start from root, since no path
 267 is searched and it is unreliable to depend on the current working directory.
 268 Redirection of input or output is not supported; the subprograms must
 269 accept filenames saying what files to read and write.
 270
 271 In addition, the specs can contain %-sequences to substitute variable text
 272 or for conditional text.  Here is a table of all defined %-sequences.
 273 Note that spaces are not generated automatically around the results of
 274 expanding these sequences; therefore, you can concatenate them together
 275 or with constant text in a single argument.
 276
 277  %%     substitute one % into the program name or argument.
 278  %i     substitute the name of the input file being processed.
 279  %b     substitute the basename of the input file being processed.
 280         This is the substring up to (and not including) the last period
 281         and not including the directory.
 282  %g     substitute the temporary-file-name-base.  This is a string chosen
 283         once per compilation.  Different temporary file names are made by
 284         concatenation of constant strings on the end, as in `%g.s'.
 285         %g also has the same effect of %d.
 286  %u     like %g, but make the temporary file name unique.
 287  %U     returns the last file name generated with %u.
 288  %d     marks the argument containing or following the %d as a
 289         temporary file name, so that that file will be deleted if CC exits
 290         successfully.  Unlike %g, this contributes no text to the argument.
 291  %w     marks the argument containing or following the %w as the
 292         "output file" of this compilation.  This puts the argument
 293         into the sequence of arguments that %o will substitute later.
 294  %W{...}
 295         like %{...} but mark last argument supplied within
 296         as a file to be deleted on failure.
 297  %o     substitutes the names of all the output files, with spaces
 298         automatically placed around them.  You should write spaces
 299         around the %o as well or the results are undefined.
 300         %o is for use in the specs for running the linker.
 301         Input files whose names have no recognized suffix are not compiled
 302         at all, but they are included among the output files, so they will
 303         be linked.
 304  %p     substitutes the standard macro predefinitions for the
 305         current target machine.  Use this when running cpp.
 306  %P     like %p, but puts `__' before and after the name of each macro.
 307         (Except macros that already have __.)
 308         This is for ANSI C.
 309  %I     Substitute a -iprefix option made from GCC_EXEC_PREFIX.
 310  %s     current argument is the name of a library or startup file of some sort.
 311         Search for that file in a standard list of directories
 312         and substitute the full name found.
 313  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 314         Use this when inconsistent options are detected.
 315  %x{OPTION}     Accumulate an option for %X.
 316  %X     Output the accumulated linker options specified by compilations.
 317  %Y     Output the accumulated assembler options specified by compilations.
 318  %v1    Substitute the major version number of GCC.
 319         (For version 2.5.n, this is 2.)
 320  %v2    Substitute the minor version number of GCC.
 321         (For version 2.5.n, this is 5.)
 322  %a     process ASM_SPEC as a spec.
 323         This allows config.h to specify part of the spec for running as.
 324  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 325         used here.  This can be used to run a post-processor after the
 326         assembler has done it's job.
 327  %D     Dump out a -L option for each directory in startfile_prefix.
 328         If multilib_dir is set, extra entries are generated with it affixed.
 329  %l     process LINK_SPEC as a spec.
 330  %L     process LIB_SPEC as a spec.
 331  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 332  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 333  %c     process SIGNED_CHAR_SPEC as a spec.
 334  %C     process CPP_SPEC as a spec.  A capital C is actually used here.
 335  %1     process CC1_SPEC as a spec.
 336  %2     process CC1PLUS_SPEC as a spec.
 337  %|     output "-" if the input for the current command is coming from a pipe.
 338  %*     substitute the variable part of a matched option.  (See below.)
 339         Note that each comma in the substituted string is replaced by
 340         a single space.
 341  %{S}   substitutes the -S switch, if that switch was given to CC.
 342         If that switch was not specified, this substitutes nothing.
 343         Here S is a metasyntactic variable.
 344  %{S*}  substitutes all the switches specified to CC whose names start
 345         with -S.  This is used for -o, -D, -I, etc; switches that take
 346         arguments.  CC considers `-o foo' as being one switch whose
 347         name starts with `o'.  %{o*} would substitute this text,
 348         including the space; thus, two arguments would be generated.
 349  %{S*:X} substitutes X if one or more switches whose names start with -S are
 350         specified to CC.  Note that the tail part of the -S option
 351         (i.e. the part matched by the `*') will be substituted for each
 352         occurrence of %* within X.
 353  %{S:X} substitutes X, but only if the -S switch was given to CC.
 354  %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
 355  %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
 356  %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
 357  %{.S:X} substitutes X, but only if processing a file with suffix S.
 358  %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
 359  %(Spec) processes a specification defined in a specs file as *Spec:
 360  %[Spec] as above, but put __ around -D arguments
 361
 362 The conditional text X in a %{S:X} or %{!S:X} construct may contain
 363 other nested % constructs or spaces, or even newlines.  They are
 364 processed as usual, as described above.
 365
 366 The -O, -f, -m, and -W switches are handled specifically in these
 367 constructs.  If another value of -O or the negated form of a -f, -m, or
 368 -W switch is found later in the command line, the earlier switch
 369 value is ignored, except with {S*} where S is just one letter; this
 370 passes all matching options.
 371
 372 The character | is used to indicate that a command should be piped to
 373 the following command, but only if -pipe is specified.
 374
 375 Note that it is built into CC which switches take arguments and which
 376 do not.  You might think it would be useful to generalize this to
 377 allow each compiler's spec to say which switches take arguments.  But
 378 this cannot be done in a consistent fashion.  CC cannot even decide
 379 which input files have been specified without knowing which switches
 380 take arguments, and it must know which input files to compile in order
 381 to tell which compilers to run.
 382
 383 CC also knows implicitly that arguments starting in `-l' are to be
 384 treated as compiler output files, and passed to the linker in their
 385 proper position among the other output files.  */
 386 \f
 387 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1.  */
 388
 389 /* config.h can define ASM_SPEC to provide extra args to the assembler
 390    or extra switch-translations.  */
 391 #ifndef ASM_SPEC
 392 #define ASM_SPEC ""
 393 #endif
 394
 395 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 396    the assembler has run.  */
 397 #ifndef ASM_FINAL_SPEC
 398 #define ASM_FINAL_SPEC ""
 399 #endif
 400
 401 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 402    or extra switch-translations.  */
 403 #ifndef CPP_SPEC
 404 #define CPP_SPEC ""
 405 #endif
 406
 407 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 408    or extra switch-translations.  */
 409 #ifndef CC1_SPEC
 410 #define CC1_SPEC ""
 411 #endif
 412
 413 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 414    or extra switch-translations.  */
 415 #ifndef CC1PLUS_SPEC
 416 #define CC1PLUS_SPEC ""
 417 #endif
 418
 419 /* config.h can define LINK_SPEC to provide extra args to the linker
 420    or extra switch-translations.  */
 421 #ifndef LINK_SPEC
 422 #define LINK_SPEC ""
 423 #endif
 424
 425 /* config.h can define LIB_SPEC to override the default libraries.  */
 426 #ifndef LIB_SPEC
 427 #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
 428 #endif
 429
 430 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 431 #ifndef STARTFILE_SPEC
 432 #define STARTFILE_SPEC  \
 433   "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
 434 #endif
 435
 436 /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
 437    Make the string nonempty to require spaces there.  */
 438 #ifndef SWITCHES_NEED_SPACES
 439 #define SWITCHES_NEED_SPACES ""
 440 #endif
 441
 442 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 443 #ifndef ENDFILE_SPEC
 444 #define ENDFILE_SPEC ""
 445 #endif
 446
 447 /* This spec is used for telling cpp whether char is signed or not.  */
 448 #ifndef SIGNED_CHAR_SPEC
 449 /* Use #if rather than ?:
 450    because MIPS C compiler rejects like ?: in initializers.  */
 451 #if DEFAULT_SIGNED_CHAR
 452 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
 453 #else
 454 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
 455 #endif
 456 #endif
 457
 458 /* MULTILIB_SELECT comes from multilib.h.  It gives a
 459    string interpreted by set_multilib_dir to select a library
 460    subdirectory based on the compiler options.  */
 461 #ifndef MULTILIB_SELECT
 462 #define MULTILIB_SELECT ". ;"
 463 #endif
 464
 465 static char *cpp_spec = CPP_SPEC;
 466 static char *cpp_predefines = CPP_PREDEFINES;
 467 static char *cc1_spec = CC1_SPEC;
 468 static char *cc1plus_spec = CC1PLUS_SPEC;
 469 static char *signed_char_spec = SIGNED_CHAR_SPEC;
 470 static char *asm_spec = ASM_SPEC;
 471 static char *asm_final_spec = ASM_FINAL_SPEC;
 472 static char *link_spec = LINK_SPEC;
 473 static char *lib_spec = LIB_SPEC;
 474 static char *endfile_spec = ENDFILE_SPEC;
 475 static char *startfile_spec = STARTFILE_SPEC;
 476 static char *switches_need_spaces = SWITCHES_NEED_SPACES;
 477 static char *multilib_select = MULTILIB_SELECT;
 478
 479 /* This defines which switch letters take arguments.  */
 480
 481 #ifndef SWITCH_TAKES_ARG
 482 #define SWITCH_TAKES_ARG(CHAR)      \
 483   ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
 484    || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
 485    || (CHAR) == 'I' || (CHAR) == 'm' \
 486    || (CHAR) == 'L' || (CHAR) == 'A')
 487 #endif
 488
 489 /* This defines which multi-letter switches take arguments.  */
 490
 491 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR)              \
 492  (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext")      \
 493   || !strcmp (STR, "Tbss") || !strcmp (STR, "include")  \
 494   || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
 495   || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
 496   || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
 497   || !strcmp (STR, "isystem"))
 498
 499 #ifndef WORD_SWITCH_TAKES_ARG
 500 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
 501 #endif
 502 \f
 503 /* Record the mapping from file suffixes for compilation specs.  */
 504
 505 struct compiler
 506 {
 507   char *suffix;                 /* Use this compiler for input files
 508                                    whose names end in this suffix.  */
 509
 510   char *spec[4];                /* To use this compiler, concatenate these
 511                                    specs and pass to do_spec.  */
 512 };
 513
 514 /* Pointer to a vector of `struct compiler' that gives the spec for
 515    compiling a file, based on its suffix.
 516    A file that does not end in any of these suffixes will be passed
 517    unchanged to the loader and nothing else will be done to it.
 518
 519    An entry containing two 0s is used to terminate the vector.
 520
 521    If multiple entries match a file, the last matching one is used.  */
 522
 523 static struct compiler *compilers;
 524
 525 /* Number of entries in `compilers', not counting the null terminator.  */
 526
 527 static int n_compilers;
 528
 529 /* The default list of file name suffixes and their compilation specs.  */
 530
 531 static struct compiler default_compilers[] =
 532 {
 533   {".c", "@c"},
 534   {"@c",
 535    "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 536         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 537         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
 538         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 539         %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 540         %{!undef:%{!ansi:%p} %P} %{trigraphs} \
 541         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 542         %{traditional-cpp:-traditional}\
 543         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 544         %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 545    "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
 546                    %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
 547                    %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
 548                    %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
 549                    %{aux-info*}\
 550                    %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 551                    %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 552               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 553                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 554                       %{!pipe:%g.s} %A\n }}}}"},
 555   {"-",
 556    "%{E:cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 557         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 558         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
 559         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 560         %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 561         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 562         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 563         %{traditional-cpp:-traditional}\
 564         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 565         %i %W{o*}}\
 566     %{!E:%e-E required when input is from standard input}"},
 567   {".m", "@objective-c"},
 568   {"@objective-c",
 569    "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 570         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 571         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
 572         -undef -D__OBJC__ -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 573          %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 574         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 575         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 576         %{traditional-cpp:-traditional}\
 577         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 578         %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 579    "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
 580                    %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
 581                    %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
 582                    %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
 583                    -lang-objc %{gen-decls} \
 584                    %{aux-info*}\
 585                    %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 586                    %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 587               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 588                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 589                       %{!pipe:%g.s} %A\n }}}}"},
 590   {".h", "@c-header"},
 591   {"@c-header",
 592    "%{!E:%eCompilation of header file requested} \
 593     cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 594         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 595          %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
 596         -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
 597          %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
 598         %{!undef:%{!ansi:%p} %P} %{trigraphs}\
 599         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 600         %{traditional-cpp:-traditional}\
 601         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 602         %i %W{o*}"},
 603   {".cc", "@c++"},
 604   {".cxx", "@c++"},
 605   {".cpp", "@c++"},
 606   {".C", "@c++"},
 607   {"@c++",
 608    "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 609         %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
 610         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
 611         -undef -D__GNUC__=%v1 -D__GNUG__=%v1 -D__cplusplus -D__GNUC_MINOR__=%v2\
 612         %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
 613         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 614         %{traditional-cpp:-traditional} %{trigraphs}\
 615         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 616         %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 617    "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\
 618                             %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
 619                             %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 620                             %{traditional} %{v:-version} %{pg:-p} %{p}\
 621                             %{f*} %{+e*} %{aux-info*}\
 622                             %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 623                             %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}}|\n\
 624               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 625                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 626                       %{!pipe:%g.s} %A\n }}}}"},
 627   {".i", "@cpp-output"},
 628   {"@cpp-output",
 629    "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
 630                         %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 631                         %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
 632                         %{aux-info*}\
 633                         %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 634                         %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 635                      %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 636                              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 637                              %{!pipe:%g.s} %A\n }}}}"},
 638   {".ii", "@c++-cpp-output"},
 639   {"@c++-cpp-output",
 640    "%{!M:%{!MM:%{!E:cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
 641                             %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 642                             %{traditional} %{v:-version} %{pg:-p} %{p}\
 643                             %{f*} %{+e*} %{aux-info*}\
 644                             %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 645                             %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 646                     %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 647                             %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 648                             %{!pipe:%g.s} %A\n }}}}"},
 649   {".s", "@assembler"},
 650   {"@assembler",
 651    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 652                             %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 653                             %i %A\n }}}}"},
 654   {".S", "@assembler-with-cpp"},
 655   {"@assembler-with-cpp",
 656    "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 657         %{C:%{!E:%eGNU C does not support -C without using -E}}\
 658         %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
 659         -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
 660         %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
 661         %{traditional-cpp:-traditional}\
 662         %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
 663         %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
 664    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 665                     %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
 666                     %{!pipe:%g.s} %A\n }}}}"},
 667   {".ads", "@ada"},
 668   {".adb", "@ada"},
 669   {".ada", "@ada"},
 670   {"@ada",
 671    "%{!M:%{!MM:%{!E:gnat1 %{k8:-gnatk8} %{w:-gnatws} %{!Q:-quiet}\
 672                            -dumpbase %b.ada %{g*} %{O*} %{p} %{pg:-p} %{f*}\
 673                           %{d*}\
 674                           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 675                           %i %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 676                     %{!S:%{!gnatc:%{!gnats:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
 677                                               %{c:%W{o*}%{!o*:-o %w%b.o}}\
 678                                               %{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n}}}}}} "},
 679   /* Mark end of table */
 680   {0, 0}
 681 };
 682
 683 /* Number of elements in default_compilers, not counting the terminator.  */
 684
 685 static int n_default_compilers
 686   = (sizeof default_compilers / sizeof (struct compiler)) - 1;
 687
 688 /* Here is the spec for running the linker, after compiling all files.  */
 689
 690 /* -u* was put back because both BSD and SysV seem to support it.  */
 691 /* %{static:} simply prevents an error message if the target machine
 692    doesn't handle -static.  */
 693 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 694    scripts which exist in user specified directories, or in standard
 695    directories.  */
 696 #ifdef LINK_LIBGCC_SPECIAL_1
 697 /* Have gcc do the search for libgcc.a, but generate -L options as usual.  */
 698 static char *link_command_spec = "\
 699 %{!fsyntax-only: \
 700  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 701                         %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
 702                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 703                         %{L*} %D %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
 704 #else
 705 #ifdef LINK_LIBGCC_SPECIAL
 706 /* Have gcc do the search for libgcc.a, and don't generate -L options.  */
 707 static char *link_command_spec = "\
 708 %{!fsyntax-only: \
 709  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 710                         %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
 711                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 712                         %{L*} %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
 713 #else
 714 /* Use -L and have the linker do the search for -lgcc.  */
 715 static char *link_command_spec = "\
 716 %{!fsyntax-only: \
 717  %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
 718                         %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
 719                         %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
 720                         %{L*} %D %{T*} %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}}";
 721 #endif
 722 #endif
 723
 724 /* A vector of options to give to the linker.
 725    These options are accumulated by -Xlinker and -Wl,
 726    and substituted into the linker command with %X.  */
 727 static int n_linker_options;
 728 static char **linker_options;
 729
 730 /* A vector of options to give to the assembler.
 731    These options are accumulated by -Wa,
 732    and substituted into the assembler command with %X.  */
 733 static int n_assembler_options;
 734 static char **assembler_options;
 735 \f
 736 /* Define how to map long options into short ones.  */
 737
 738 /* This structure describes one mapping.  */
 739 struct option_map
 740 {
 741   /* The long option's name.  */
 742   char *name;
 743   /* The equivalent short option.  */
 744   char *equivalent;
 745   /* Argument info.  A string of flag chars; NULL equals no options.
 746      a => argument required.
 747      o => argument optional.
 748      j => join argument to equivalent, making one word.
 749      * => allow other text after NAME as an argument.  */
 750   char *arg_info;
 751 };
 752
 753 /* This is the table of mappings.  Mappings are tried sequentially
 754    for each option encountered; the first one that matches, wins.  */
 755
 756 struct option_map option_map[] =
 757  {
 758    {"--profile-blocks", "-a", 0},
 759    {"--target", "-b", "a"},
 760    {"--compile", "-c", 0},
 761    {"--dump", "-d", "a"},
 762    {"--entry", "-e", 0},
 763    {"--debug", "-g", "oj"},
 764    {"--include", "-include", "a"},
 765    {"--imacros", "-imacros", "a"},
 766    {"--include-prefix", "-iprefix", "a"},
 767    {"--include-directory-after", "-idirafter", "a"},
 768    {"--include-with-prefix", "-iwithprefix", "a"},
 769    {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
 770    {"--include-with-prefix-after", "-iwithprefix", "a"},
 771    {"--machine-", "-m", "*j"},
 772    {"--machine", "-m", "aj"},
 773    {"--no-standard-includes", "-nostdinc", 0},
 774    {"--no-standard-libraries", "-nostdlib", 0},
 775    {"--no-precompiled-includes", "-noprecomp", 0},
 776    {"--output", "-o", "a"},
 777    {"--profile", "-p", 0},
 778    {"--quiet", "-q", 0},
 779    {"--silent", "-q", 0},
 780    {"--force-link", "-u", "a"},
 781    {"--verbose", "-v", 0},
 782    {"--version", "-dumpversion", 0},
 783    {"--no-warnings", "-w", 0},
 784    {"--language", "-x", "a"},
 785
 786    {"--assert", "-A", "a"},
 787    {"--prefix", "-B", "a"},
 788    {"--comments", "-C", 0},
 789    {"--define-macro", "-D", "a"},
 790    {"--preprocess", "-E", 0},
 791    {"--trace-includes", "-H", 0},
 792    {"--include-directory", "-I", "a"},
 793    {"--include-barrier", "-I-", 0},
 794    {"--library-directory", "-L", "a"},
 795    {"--dependencies", "-M", 0},
 796    {"--user-dependencies", "-MM", 0},
 797    {"--write-dependencies", "-MD", 0},
 798    {"--write-user-dependencies", "-MMD", 0},
 799    {"--print-missing-file-dependencies", "-MG", 0},
 800    {"--optimize", "-O", "oj"},
 801    {"--no-line-commands", "-P", 0},
 802    {"--assemble", "-S", 0},
 803    {"--undefine-macro", "-U", "a"},
 804    {"--use-version", "-V", "a"},
 805    {"--for-assembler", "-Wa", "a"},
 806    {"--extra-warnings", "-W", 0},
 807    {"--all-warnings", "-Wall", 0},
 808    {"--warn-", "-W", "*j"},
 809    {"--for-linker", "-Xlinker", "a"},
 810
 811    {"--ansi", "-ansi", 0},
 812    {"--traditional", "-traditional", 0},
 813    {"--traditional-cpp", "-traditional-cpp", 0},
 814    {"--trigraphs", "-trigraphs", 0},
 815    {"--pipe", "-pipe", 0},
 816    {"--dumpbase", "-dumpbase", "a"},
 817    {"--pedantic", "-pedantic", 0},
 818    {"--pedantic-errors", "-pedantic-errors", 0},
 819    {"--save-temps", "-save-temps", 0},
 820    {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
 821    {"--print-file-name", "-print-file-name=", "aj"},
 822    {"--print-prog-name", "-print-prog-name=", "aj"},
 823    {"--print-multi-lib", "-print-multi-lib", 0},
 824    {"--print-multi-directory", "-print-multi-directory", 0},
 825    {"--static", "-static", 0},
 826    {"--shared", "-shared", 0},
 827    {"--symbolic", "-symbolic", 0},
 828    {"--", "-f", "*j"}
 829  };
 830 \f
 831 /* Translate the options described by *ARGCP and *ARGVP.
 832    Make a new vector and store it back in *ARGVP,
 833    and store its length in *ARGVC.  */
 834
 835 static void
 836 translate_options (argcp, argvp)
 837      int *argcp;
 838      char ***argvp;
 839 {
 840   int i, j;
 841   int argc = *argcp;
 842   char **argv = *argvp;
 843   char **newv = (char **) xmalloc ((argc + 2) * 2 * sizeof (char *));
 844   int newindex = 0;
 845
 846   i = 0;
 847   newv[newindex++] = argv[i++];
 848
 849   while (i < argc)
 850     {
 851       /* Translate -- options.  */
 852       if (argv[i][0] == '-' && argv[i][1] == '-')
 853         {
 854           /* Find a mapping that applies to this option.  */
 855           for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
 856             {
 857               int optlen = strlen (option_map[j].name);
 858               int complen = strlen (argv[i]);
 859               char *arginfo = option_map[j].arg_info;
 860
 861               if (arginfo == 0)
 862                 arginfo = "";
 863               if (complen > optlen)
 864                 complen = optlen;
 865               if (!strncmp (argv[i], option_map[j].name, complen))
 866                 {
 867                   int extra = strlen (argv[i]) > optlen;
 868                   char *arg = 0;
 869
 870                   if (extra)
 871                     {
 872                       /* If the option has an argument, accept that.  */
 873                       if (argv[i][optlen] == '=')
 874                         arg = argv[i] + optlen + 1;
 875                       /* If this mapping allows extra text at end of name,
 876                          accept that as "argument".  */
 877                       else if (index (arginfo, '*') != 0)
 878                         arg = argv[i] + optlen;
 879                       /* Otherwise, extra text at end means mismatch.
 880                          Try other mappings.  */
 881                       else
 882                         continue;
 883                     }
 884                   else if (index (arginfo, '*') != 0)
 885                     error ("Incomplete `%s' option", option_map[j].name);
 886
 887                   /* Handle arguments.  */
 888                   if (index (arginfo, 'o') != 0)
 889                     {
 890                       if (arg == 0)
 891                         {
 892                           if (i + 1 == argc)
 893                             error ("Missing argument to `%s' option",
 894                                    option_map[j].name);
 895                           arg = argv[++i];
 896                         }
 897                     }
 898                   else if (index (arginfo, '*') != 0)
 899                     ;
 900                   else if (index (arginfo, 'a') == 0)
 901                     {
 902                       if (arg != 0)
 903                         error ("Extraneous argument to `%s' option",
 904                                option_map[j].name);
 905                       arg = 0;
 906                     }
 907
 908                   /* Store the translation as one argv elt or as two.  */
 909                   if (arg != 0 && index (arginfo, 'j') != 0)
 910                     newv[newindex++] = concat (option_map[j].equivalent,
 911                                                arg, "");
 912                   else if (arg != 0)
 913                     {
 914                       newv[newindex++] = option_map[j].equivalent;
 915                       newv[newindex++] = arg;
 916                     }
 917                   else
 918                     newv[newindex++] = option_map[j].equivalent;
 919
 920                   break;
 921                 }
 922             }
 923           i++;
 924         }
 925       /* Handle old-fashioned options--just copy them through,
 926          with their arguments.  */
 927       else if (argv[i][0] == '-')
 928         {
 929           char *p = argv[i] + 1;
 930           int c = *p;
 931           int nskip = 1;
 932
 933           if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
 934             nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
 935           else if (WORD_SWITCH_TAKES_ARG (p))
 936             nskip += WORD_SWITCH_TAKES_ARG (p);
 937           else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
 938                    && p[1] == 0)
 939             nskip += 1;
 940           else if (! strcmp (p, "Xlinker"))
 941             nskip += 1;
 942
 943           /* Watch out for an option at the end of the command line that
 944              is missing arguments, and avoid skipping past the end of the
 945              command line.  */
 946           if (nskip + i > argc)
 947             nskip = argc - i;
 948
 949           while (nskip > 0)
 950             {
 951               newv[newindex++] = argv[i++];
 952               nskip--;
 953             }
 954         }
 955       else
 956         /* Ordinary operands, or +e options.  */
 957         newv[newindex++] = argv[i++];
 958     }
 959
 960   newv[newindex] = 0;
 961
 962   *argvp = newv;
 963   *argcp = newindex;
 964 }
 965 \f
 966 /* Read compilation specs from a file named FILENAME,
 967    replacing the default ones.
 968
 969    A suffix which starts with `*' is a definition for
 970    one of the machine-specific sub-specs.  The "suffix" should be
 971    *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
 972    The corresponding spec is stored in asm_spec, etc.,
 973    rather than in the `compilers' vector.
 974
 975    Anything invalid in the file is a fatal error.  */
 976
 977 static void
 978 read_specs (filename)
 979      char *filename;
 980 {
 981   int desc;
 982   struct stat statbuf;
 983   char *buffer;
 984   register char *p;
 985
 986   if (verbose_flag)
 987     fprintf (stderr, "Reading specs from %s\n", filename);
 988
 989   /* Open and stat the file.  */
 990   desc = open (filename, 0, 0);
 991   if (desc < 0)
 992     pfatal_with_name (filename);
 993   if (stat (filename, &statbuf) < 0)
 994     pfatal_with_name (filename);
 995
 996   /* Read contents of file into BUFFER.  */
 997   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
 998   read (desc, buffer, (unsigned) statbuf.st_size);
 999   buffer[statbuf.st_size] = 0;
1000   close (desc);
1001
1002   /* Scan BUFFER for specs, putting them in the vector.  */
1003   p = buffer;
1004   while (1)
1005     {
1006       char *suffix;
1007       char *spec;
1008       char *in, *out, *p1, *p2;
1009
1010       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1011       p = skip_whitespace (p);
1012       if (*p == 0)
1013         break;
1014
1015       /* Find the colon that should end the suffix.  */
1016       p1 = p;
1017       while (*p1 && *p1 != ':' && *p1 != '\n') p1++;
1018       /* The colon shouldn't be missing.  */
1019       if (*p1 != ':')
1020         fatal ("specs file malformed after %d characters", p1 - buffer);
1021       /* Skip back over trailing whitespace.  */
1022       p2 = p1;
1023       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) p2--;
1024       /* Copy the suffix to a string.  */
1025       suffix = save_string (p, p2 - p);
1026       /* Find the next line.  */
1027       p = skip_whitespace (p1 + 1);
1028       if (p[1] == 0)
1029         fatal ("specs file malformed after %d characters", p - buffer);
1030       p1 = p;
1031       /* Find next blank line.  */
1032       while (*p1 && !(*p1 == '\n' && p1[1] == '\n')) p1++;
1033       /* Specs end at the blank line and do not include the newline.  */
1034       spec = save_string (p, p1 - p);
1035       p = p1;
1036
1037       /* Delete backslash-newline sequences from the spec.  */
1038       in = spec;
1039       out = spec;
1040       while (*in != 0)
1041         {
1042           if (in[0] == '\\' && in[1] == '\n')
1043             in += 2;
1044           else if (in[0] == '#')
1045             {
1046               while (*in && *in != '\n') in++;
1047             }
1048           else
1049             *out++ = *in++;
1050         }
1051       *out = 0;
1052
1053       if (suffix[0] == '*')
1054         {
1055           if (! strcmp (suffix, "*link_command"))
1056             link_command_spec = spec;
1057           else
1058             set_spec (suffix + 1, spec);
1059         }
1060       else
1061         {
1062           /* Add this pair to the vector.  */
1063           compilers
1064             = ((struct compiler *)
1065                xrealloc (compilers, (n_compilers + 2) * sizeof (struct compiler)));
1066           compilers[n_compilers].suffix = suffix;
1067           bzero ((char *) compilers[n_compilers].spec,
1068                  sizeof compilers[n_compilers].spec);
1069           compilers[n_compilers].spec[0] = spec;
1070           n_compilers++;
1071           bzero ((char *) &compilers[n_compilers],
1072                  sizeof compilers[n_compilers]);
1073         }
1074
1075       if (*suffix == 0)
1076         link_command_spec = spec;
1077     }
1078
1079   if (link_command_spec == 0)
1080     fatal ("spec file has no spec for linking");
1081 }
1082
1083 static char *
1084 skip_whitespace (p)
1085      char *p;
1086 {
1087   while (1)
1088     {
1089       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1090          be considered whitespace.  */
1091       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1092         return p + 1;
1093       else if (*p == '\n' || *p == ' ' || *p == '\t')
1094         p++;
1095       else if (*p == '#')
1096         {
1097           while (*p != '\n') p++;
1098           p++;
1099         }
1100       else
1101         break;
1102     }
1103
1104   return p;
1105 }
1106 \f
1107 /* Structure to keep track of the specs that have been defined so far.  These
1108    are accessed using %(specname) or %[specname] in a compiler or link spec. */
1109
1110 struct spec_list
1111 {
1112   char *name;                 /* Name of the spec. */
1113   char *spec;                 /* The spec itself. */
1114   struct spec_list *next;     /* Next spec in linked list. */
1115 };
1116
1117 /* List of specs that have been defined so far. */
1118
1119 static struct spec_list *specs = (struct spec_list *) 0;
1120 \f
1121 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1122    removed; If the spec starts with a + then SPEC is added to the end of the
1123    current spec. */
1124
1125 static void
1126 set_spec (name, spec)
1127      char *name;
1128      char *spec;
1129 {
1130   struct spec_list *sl;
1131   char *old_spec;
1132
1133   /* See if the spec already exists */
1134   for (sl = specs; sl; sl = sl->next)
1135     if (strcmp (sl->name, name) == 0)
1136       break;
1137
1138   if (!sl)
1139     {
1140       /* Not found - make it */
1141       sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1142       sl->name = save_string (name, strlen (name));
1143       sl->spec = save_string ("", 0);
1144       sl->next = specs;
1145       specs = sl;
1146     }
1147
1148   old_spec = sl->spec;
1149   if (name && spec[0] == '+' && isspace (spec[1]))
1150     sl->spec = concat (old_spec, spec + 1, "");
1151   else
1152     sl->spec = save_string (spec, strlen (spec));
1153
1154   if (! strcmp (name, "asm"))
1155     asm_spec = sl->spec;
1156   else if (! strcmp (name, "asm_final"))
1157     asm_final_spec = sl->spec;
1158   else if (! strcmp (name, "cc1"))
1159     cc1_spec = sl->spec;
1160   else if (! strcmp (name, "cc1plus"))
1161     cc1plus_spec = sl->spec;
1162   else if (! strcmp (name, "cpp"))
1163     cpp_spec = sl->spec;
1164   else if (! strcmp (name, "endfile"))
1165     endfile_spec = sl->spec;
1166   else if (! strcmp (name, "lib"))
1167     lib_spec = sl->spec;
1168   else if (! strcmp (name, "link"))
1169     link_spec = sl->spec;
1170   else if (! strcmp (name, "predefines"))
1171     cpp_predefines = sl->spec;
1172   else if (! strcmp (name, "signed_char"))
1173     signed_char_spec = sl->spec;
1174   else if (! strcmp (name, "startfile"))
1175     startfile_spec = sl->spec;
1176   else if (! strcmp (name, "switches_need_spaces"))
1177     switches_need_spaces = sl->spec;
1178   else if (! strcmp (name, "cross_compile"))
1179     cross_compile = atoi (sl->spec);
1180   else if (! strcmp (name, "multilib"))
1181     multilib_select = sl->spec;
1182   /* Free the old spec */
1183   if (old_spec)
1184     free (old_spec);
1185 }
1186 \f
1187 /* Accumulate a command (program name and args), and run it.  */
1188
1189 /* Vector of pointers to arguments in the current line of specifications.  */
1190
1191 static char **argbuf;
1192
1193 /* Number of elements allocated in argbuf.  */
1194
1195 static int argbuf_length;
1196
1197 /* Number of elements in argbuf currently in use (containing args).  */
1198
1199 static int argbuf_index;
1200
1201 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1202    temp file.  Used only if MKTEMP_EACH_FILE.  */
1203
1204 static struct temp_name {
1205   char *suffix;         /* suffix associated with the code.  */
1206   int length;           /* strlen (suffix).  */
1207   int unique;           /* Indicates whether %g or %u/%U was used.  */
1208   char *filename;       /* associated filename.  */
1209   int filename_length;  /* strlen (filename).  */
1210   struct temp_name *next;
1211 } *temp_names;
1212
1213 /* Number of commands executed so far.  */
1214
1215 static int execution_count;
1216
1217 /* Number of commands that exited with a signal.  */
1218
1219 static int signal_count;
1220
1221 /* Name with which this program was invoked.  */
1222
1223 static char *programname;
1224 \f
1225 /* Structures to keep track of prefixes to try when looking for files. */
1226
1227 struct prefix_list
1228 {
1229   char *prefix;               /* String to prepend to the path. */
1230   struct prefix_list *next;   /* Next in linked list. */
1231   int require_machine_suffix; /* Don't use without machine_suffix.  */
1232   /* 2 means try both machine_suffix and just_machine_suffix.  */
1233   int *used_flag_ptr;         /* 1 if a file was found with this prefix.  */
1234 };
1235
1236 struct path_prefix
1237 {
1238   struct prefix_list *plist;  /* List of prefixes to try */
1239   int max_len;                /* Max length of a prefix in PLIST */
1240   char *name;                 /* Name of this list (used in config stuff) */
1241 };
1242
1243 /* List of prefixes to try when looking for executables. */
1244
1245 static struct path_prefix exec_prefix = { 0, 0, "exec" };
1246
1247 /* List of prefixes to try when looking for startup (crt0) files. */
1248
1249 static struct path_prefix startfile_prefix = { 0, 0, "startfile" };
1250
1251 /* List of prefixes to try when looking for include files.  */
1252
1253 static struct path_prefix include_prefix = { 0, 0, "include" };
1254
1255 /* Suffix to attach to directories searched for commands.
1256    This looks like `MACHINE/VERSION/'.  */
1257
1258 static char *machine_suffix = 0;
1259
1260 /* Suffix to attach to directories searched for commands.
1261    This is just `MACHINE/'.  */
1262
1263 static char *just_machine_suffix = 0;
1264
1265 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1266
1267 static char *gcc_exec_prefix;
1268
1269 /* Default prefixes to attach to command names.  */
1270
1271 #ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
1272 #undef MD_EXEC_PREFIX
1273 #undef MD_STARTFILE_PREFIX
1274 #undef MD_STARTFILE_PREFIX_1
1275 #endif
1276
1277 #ifndef STANDARD_EXEC_PREFIX
1278 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1279 #endif /* !defined STANDARD_EXEC_PREFIX */
1280
1281 static char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1282 static char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1283 #ifdef MD_EXEC_PREFIX
1284 static char *md_exec_prefix = MD_EXEC_PREFIX;
1285 #endif
1286
1287 #ifndef STANDARD_STARTFILE_PREFIX
1288 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1289 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1290
1291 #ifdef MD_STARTFILE_PREFIX
1292 static char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1293 #endif
1294 #ifdef MD_STARTFILE_PREFIX_1
1295 static char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1296 #endif
1297 static char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1298 static char *standard_startfile_prefix_1 = "/lib/";
1299 static char *standard_startfile_prefix_2 = "/usr/lib/";
1300
1301 #ifndef TOOLDIR_BASE_PREFIX
1302 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1303 #endif
1304 static char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1305 static char *tooldir_prefix;
1306
1307 /* Subdirectory to use for locating libraries.  Set by
1308    set_multilib_dir based on the compilation options.  */
1309
1310 static char *multilib_dir;
1311
1312 /* Clear out the vector of arguments (after a command is executed).  */
1313
1314 static void
1315 clear_args ()
1316 {
1317   argbuf_index = 0;
1318 }
1319
1320 /* Add one argument to the vector at the end.
1321    This is done when a space is seen or at the end of the line.
1322    If DELETE_ALWAYS is nonzero, the arg is a filename
1323     and the file should be deleted eventually.
1324    If DELETE_FAILURE is nonzero, the arg is a filename
1325     and the file should be deleted if this compilation fails.  */
1326
1327 static void
1328 store_arg (arg, delete_always, delete_failure)
1329      char *arg;
1330      int delete_always, delete_failure;
1331 {
1332   if (argbuf_index + 1 == argbuf_length)
1333     {
1334       argbuf = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1335     }
1336
1337   argbuf[argbuf_index++] = arg;
1338   argbuf[argbuf_index] = 0;
1339
1340   if (delete_always || delete_failure)
1341     record_temp_file (arg, delete_always, delete_failure);
1342 }
1343 \f
1344 /* Record the names of temporary files we tell compilers to write,
1345    and delete them at the end of the run.  */
1346
1347 /* This is the common prefix we use to make temp file names.
1348    It is chosen once for each run of this program.
1349    It is substituted into a spec by %g.
1350    Thus, all temp file names contain this prefix.
1351    In practice, all temp file names start with this prefix.
1352
1353    This prefix comes from the envvar TMPDIR if it is defined;
1354    otherwise, from the P_tmpdir macro if that is defined;
1355    otherwise, in /usr/tmp or /tmp.  */
1356
1357 static char *temp_filename;
1358
1359 /* Length of the prefix.  */
1360
1361 static int temp_filename_length;
1362
1363 /* Define the list of temporary files to delete.  */
1364
1365 struct temp_file
1366 {
1367   char *name;
1368   struct temp_file *next;
1369 };
1370
1371 /* Queue of files to delete on success or failure of compilation.  */
1372 static struct temp_file *always_delete_queue;
1373 /* Queue of files to delete on failure of compilation.  */
1374 static struct temp_file *failure_delete_queue;
1375
1376 /* Record FILENAME as a file to be deleted automatically.
1377    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1378    otherwise delete it in any case.
1379    FAIL_DELETE nonzero means delete it if a compilation step fails;
1380    otherwise delete it in any case.  */
1381
1382 static void
1383 record_temp_file (filename, always_delete, fail_delete)
1384      char *filename;
1385      int always_delete;
1386      int fail_delete;
1387 {
1388   register char *name;
1389   name = xmalloc (strlen (filename) + 1);
1390   strcpy (name, filename);
1391
1392   if (always_delete)
1393     {
1394       register struct temp_file *temp;
1395       for (temp = always_delete_queue; temp; temp = temp->next)
1396         if (! strcmp (name, temp->name))
1397           goto already1;
1398       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1399       temp->next = always_delete_queue;
1400       temp->name = name;
1401       always_delete_queue = temp;
1402     already1:;
1403     }
1404
1405   if (fail_delete)
1406     {
1407       register struct temp_file *temp;
1408       for (temp = failure_delete_queue; temp; temp = temp->next)
1409         if (! strcmp (name, temp->name))
1410           goto already2;
1411       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1412       temp->next = failure_delete_queue;
1413       temp->name = name;
1414       failure_delete_queue = temp;
1415     already2:;
1416     }
1417 }
1418
1419 /* Delete all the temporary files whose names we previously recorded.  */
1420
1421 static void
1422 delete_if_ordinary (name)
1423      char *name;
1424 {
1425   struct stat st;
1426 #ifdef DEBUG
1427   int i, c;
1428
1429   printf ("Delete %s? (y or n) ", name);
1430   fflush (stdout);
1431   i = getchar ();
1432   if (i != '\n')
1433     while ((c = getchar ()) != '\n' && c != EOF) ;
1434   if (i == 'y' || i == 'Y')
1435 #endif /* DEBUG */
1436     if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
1437       if (unlink (name) < 0)
1438         if (verbose_flag)
1439           perror_with_name (name);
1440 }
1441
1442 static void
1443 delete_temp_files ()
1444 {
1445   register struct temp_file *temp;
1446
1447   for (temp = always_delete_queue; temp; temp = temp->next)
1448     delete_if_ordinary (temp->name);
1449   always_delete_queue = 0;
1450 }
1451
1452 /* Delete all the files to be deleted on error.  */
1453
1454 static void
1455 delete_failure_queue ()
1456 {
1457   register struct temp_file *temp;
1458
1459   for (temp = failure_delete_queue; temp; temp = temp->next)
1460     delete_if_ordinary (temp->name);
1461 }
1462
1463 static void
1464 clear_failure_queue ()
1465 {
1466   failure_delete_queue = 0;
1467 }
1468
1469 /* Compute a string to use as the base of all temporary file names.
1470    It is substituted for %g.  */
1471
1472 static char *
1473 choose_temp_base_try (try, base)
1474      char *try;
1475      char *base;
1476 {
1477   char *rv;
1478   if (base)
1479     rv = base;
1480   else if (try == (char *)0)
1481     rv = 0;
1482   else if (access (try, R_OK | W_OK) != 0)
1483     rv = 0;
1484   else
1485     rv = try;
1486   return rv;
1487 }
1488
1489 static void
1490 choose_temp_base ()
1491 {
1492   char *base = 0;
1493   int len;
1494
1495   base = choose_temp_base_try (getenv ("TMPDIR"), base);
1496   base = choose_temp_base_try (getenv ("TMP"), base);
1497   base = choose_temp_base_try (getenv ("TEMP"), base);
1498
1499 #ifdef P_tmpdir
1500   base = choose_temp_base_try (P_tmpdir, base);
1501 #endif
1502
1503   base = choose_temp_base_try ("/usr/tmp", base);
1504   base = choose_temp_base_try ("/tmp", base);
1505
1506   /* If all else fails, use the current directory! */
1507   if (base == (char *)0)
1508     base = "./";
1509
1510   len = strlen (base);
1511   temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
1512   strcpy (temp_filename, base);
1513   if (len > 0 && temp_filename[len-1] != '/')
1514     temp_filename[len++] = '/';
1515   strcpy (temp_filename + len, "ccXXXXXX");
1516
1517   mktemp (temp_filename);
1518   temp_filename_length = strlen (temp_filename);
1519   if (temp_filename_length == 0)
1520     abort ();
1521 }
1522 \f
1523
1524 /* Routine to add variables to the environment.  We do this to pass
1525    the pathname of the gcc driver, and the directories search to the
1526    collect2 program, which is being run as ld.  This way, we can be
1527    sure of executing the right compiler when collect2 wants to build
1528    constructors and destructors.  Since the environment variables we
1529    use come from an obstack, we don't have to worry about allocating
1530    space for them.  */
1531
1532 #ifndef HAVE_PUTENV
1533
1534 void
1535 putenv (str)
1536      char *str;
1537 {
1538 #ifndef VMS                     /* nor about VMS */
1539
1540   extern char **environ;
1541   char **old_environ = environ;
1542   char **envp;
1543   int num_envs = 0;
1544   int name_len = 1;
1545   int str_len = strlen (str);
1546   char *p = str;
1547   int ch;
1548
1549   while ((ch = *p++) != '\0' && ch != '=')
1550     name_len++;
1551
1552   if (!ch)
1553     abort ();
1554
1555   /* Search for replacing an existing environment variable, and
1556      count the number of total environment variables.  */
1557   for (envp = old_environ; *envp; envp++)
1558     {
1559       num_envs++;
1560       if (!strncmp (str, *envp, name_len))
1561         {
1562           *envp = str;
1563           return;
1564         }
1565     }
1566
1567   /* Add a new environment variable */
1568   environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1569   *environ = str;
1570   bcopy ((char *) old_environ, (char *) (environ + 1),
1571          sizeof (char *) * (num_envs+1));
1572
1573 #endif  /* VMS */
1574 }
1575
1576 #endif  /* HAVE_PUTENV */
1577
1578 \f
1579 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect.  */
1580
1581 static void
1582 putenv_from_prefixes (paths, env_var)
1583      struct path_prefix *paths;
1584      char *env_var;
1585 {
1586   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1587   int just_suffix_len
1588     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1589   int first_time = TRUE;
1590   struct prefix_list *pprefix;
1591
1592   obstack_grow (&collect_obstack, env_var, strlen (env_var));
1593
1594   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1595     {
1596       int len = strlen (pprefix->prefix);
1597
1598       if (machine_suffix
1599           && is_directory (pprefix->prefix, machine_suffix, 0))
1600         {
1601           if (!first_time)
1602             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1603
1604           first_time = FALSE;
1605           obstack_grow (&collect_obstack, pprefix->prefix, len);
1606           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1607         }
1608
1609       if (just_machine_suffix
1610           && pprefix->require_machine_suffix == 2
1611           && is_directory (pprefix->prefix, just_machine_suffix, 0))
1612         {
1613           if (!first_time)
1614             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1615
1616           first_time = FALSE;
1617           obstack_grow (&collect_obstack, pprefix->prefix, len);
1618           obstack_grow (&collect_obstack, just_machine_suffix,
1619                         just_suffix_len);
1620         }
1621
1622       if (!pprefix->require_machine_suffix)
1623         {
1624           if (!first_time)
1625             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1626
1627           first_time = FALSE;
1628           obstack_grow (&collect_obstack, pprefix->prefix, len);
1629         }
1630     }
1631   obstack_1grow (&collect_obstack, '\0');
1632   putenv (obstack_finish (&collect_obstack));
1633 }
1634
1635 \f
1636 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
1637    access to check permissions.
1638    Return 0 if not found, otherwise return its name, allocated with malloc. */
1639
1640 static char *
1641 find_a_file (pprefix, name, mode)
1642      struct path_prefix *pprefix;
1643      char *name;
1644      int mode;
1645 {
1646   char *temp;
1647   char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1648   struct prefix_list *pl;
1649   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1650
1651   if (machine_suffix)
1652     len += strlen (machine_suffix);
1653
1654   temp = xmalloc (len);
1655
1656   /* Determine the filename to execute (special case for absolute paths).  */
1657
1658   if (*name == '/')
1659     {
1660       if (access (name, mode))
1661         {
1662           strcpy (temp, name);
1663           return temp;
1664         }
1665     }
1666   else
1667     for (pl = pprefix->plist; pl; pl = pl->next)
1668       {
1669         if (machine_suffix)
1670           {
1671             /* Some systems have a suffix for executable files.
1672                So try appending that first.  */
1673             if (file_suffix[0] != 0)
1674               {
1675                 strcpy (temp, pl->prefix);
1676                 strcat (temp, machine_suffix);
1677                 strcat (temp, name);
1678                 strcat (temp, file_suffix);
1679                 if (access (temp, mode) == 0)
1680                   {
1681                     if (pl->used_flag_ptr != 0)
1682                       *pl->used_flag_ptr = 1;
1683                     return temp;
1684                   }
1685               }
1686
1687             /* Now try just the name.  */
1688             strcpy (temp, pl->prefix);
1689             strcat (temp, machine_suffix);
1690             strcat (temp, name);
1691             if (access (temp, mode) == 0)
1692               {
1693                 if (pl->used_flag_ptr != 0)
1694                   *pl->used_flag_ptr = 1;
1695                 return temp;
1696               }
1697           }
1698
1699         /* Certain prefixes are tried with just the machine type,
1700            not the version.  This is used for finding as, ld, etc.  */
1701         if (just_machine_suffix && pl->require_machine_suffix == 2)
1702           {
1703             /* Some systems have a suffix for executable files.
1704                So try appending that first.  */
1705             if (file_suffix[0] != 0)
1706               {
1707                 strcpy (temp, pl->prefix);
1708                 strcat (temp, just_machine_suffix);
1709                 strcat (temp, name);
1710                 strcat (temp, file_suffix);
1711                 if (access (temp, mode) == 0)
1712                   {
1713                     if (pl->used_flag_ptr != 0)
1714                       *pl->used_flag_ptr = 1;
1715                     return temp;
1716                   }
1717               }
1718
1719             strcpy (temp, pl->prefix);
1720             strcat (temp, just_machine_suffix);
1721             strcat (temp, name);
1722             if (access (temp, mode) == 0)
1723               {
1724                 if (pl->used_flag_ptr != 0)
1725                   *pl->used_flag_ptr = 1;
1726                 return temp;
1727               }
1728           }
1729
1730         /* Certain prefixes can't be used without the machine suffix
1731            when the machine or version is explicitly specified.  */
1732         if (!pl->require_machine_suffix)
1733           {
1734             /* Some systems have a suffix for executable files.
1735                So try appending that first.  */
1736             if (file_suffix[0] != 0)
1737               {
1738                 strcpy (temp, pl->prefix);
1739                 strcat (temp, name);
1740                 strcat (temp, file_suffix);
1741                 if (access (temp, mode) == 0)
1742                   {
1743                     if (pl->used_flag_ptr != 0)
1744                       *pl->used_flag_ptr = 1;
1745                     return temp;
1746                   }
1747               }
1748
1749             strcpy (temp, pl->prefix);
1750             strcat (temp, name);
1751             if (access (temp, mode) == 0)
1752               {
1753                 if (pl->used_flag_ptr != 0)
1754                   *pl->used_flag_ptr = 1;
1755                 return temp;
1756               }
1757           }
1758       }
1759
1760   free (temp);
1761   return 0;
1762 }
1763
1764 /* Add an entry for PREFIX in PLIST.  If FIRST is set, it goes
1765    at the start of the list, otherwise it goes at the end.
1766
1767    If WARN is nonzero, we will warn if no file is found
1768    through this prefix.  WARN should point to an int
1769    which will be set to 1 if this entry is used.
1770
1771    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
1772    the complete value of machine_suffix.
1773    2 means try both machine_suffix and just_machine_suffix.  */
1774
1775 static void
1776 add_prefix (pprefix, prefix, first, require_machine_suffix, warn)
1777      struct path_prefix *pprefix;
1778      char *prefix;
1779      int first;
1780      int require_machine_suffix;
1781      int *warn;
1782 {
1783   struct prefix_list *pl, **prev;
1784   int len;
1785
1786   if (!first && pprefix->plist)
1787     {
1788       for (pl = pprefix->plist; pl->next; pl = pl->next)
1789         ;
1790       prev = &pl->next;
1791     }
1792   else
1793     prev = &pprefix->plist;
1794
1795   /* Keep track of the longest prefix */
1796
1797   len = strlen (prefix);
1798   if (len > pprefix->max_len)
1799     pprefix->max_len = len;
1800
1801   pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
1802   pl->prefix = save_string (prefix, len);
1803   pl->require_machine_suffix = require_machine_suffix;
1804   pl->used_flag_ptr = warn;
1805   if (warn)
1806     *warn = 0;
1807
1808   if (*prev)
1809     pl->next = *prev;
1810   else
1811     pl->next = (struct prefix_list *) 0;
1812   *prev = pl;
1813 }
1814
1815 /* Print warnings for any prefixes in the list PPREFIX that were not used.  */
1816
1817 static void
1818 unused_prefix_warnings (pprefix)
1819      struct path_prefix *pprefix;
1820 {
1821   struct prefix_list *pl = pprefix->plist;
1822
1823   while (pl)
1824     {
1825       if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
1826         {
1827           error ("file path prefix `%s' never used",
1828                  pl->prefix);
1829           /* Prevent duplicate warnings.  */
1830           *pl->used_flag_ptr = 1;
1831         }
1832       pl = pl->next;
1833     }
1834 }
1835
1836 /* Get rid of all prefixes built up so far in *PLISTP. */
1837
1838 static void
1839 free_path_prefix (pprefix)
1840      struct path_prefix *pprefix;
1841 {
1842   struct prefix_list *pl = pprefix->plist;
1843   struct prefix_list *temp;
1844
1845   while (pl)
1846     {
1847       temp = pl;
1848       pl = pl->next;
1849       free (temp->prefix);
1850       free ((char *) temp);
1851     }
1852   pprefix->plist = (struct prefix_list *) 0;
1853 }
1854 \f
1855 /* stdin file number.  */
1856 #define STDIN_FILE_NO 0
1857
1858 /* stdout file number.  */
1859 #define STDOUT_FILE_NO 1
1860
1861 /* value of `pipe': port index for reading.  */
1862 #define READ_PORT 0
1863
1864 /* value of `pipe': port index for writing.  */
1865 #define WRITE_PORT 1
1866
1867 /* Pipe waiting from last process, to be used as input for the next one.
1868    Value is STDIN_FILE_NO if no pipe is waiting
1869    (i.e. the next command is the first of a group).  */
1870
1871 static int last_pipe_input;
1872
1873 /* Fork one piped subcommand.  FUNC is the system call to use
1874    (either execv or execvp).  ARGV is the arg vector to use.
1875    NOT_LAST is nonzero if this is not the last subcommand
1876    (i.e. its output should be piped to the next one.)  */
1877
1878 #ifndef OS2
1879 #ifdef __MSDOS__
1880
1881 #include <process.h>
1882 static int
1883 pexecute (search_flag, program, argv, not_last)
1884      int search_flag;
1885      char *program;
1886      char *argv[];
1887      int not_last;
1888 {
1889 #ifdef __GO32__
1890   int i = (search_flag ? spawnv : spawnvp) (1, program, argv);
1891 #else
1892   char *scmd, *rf;
1893   FILE *argfile;
1894   int i, el = search_flag ? 0 : 4;
1895
1896   scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 6 + el);
1897   rf = scmd + strlen(program) + 2 + el;
1898   sprintf (scmd, "%s%s @%s.gp", program,
1899            (search_flag ? "" : ".exe"), temp_filename);
1900   argfile = fopen (rf, "w");
1901   if (argfile == 0)
1902     pfatal_with_name (rf);
1903
1904   for (i=1; argv[i]; i++)
1905     {
1906       char *cp;
1907       for (cp = argv[i]; *cp; cp++)
1908         {
1909           if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
1910             fputc ('\\', argfile);
1911           fputc (*cp, argfile);
1912         }
1913       fputc ('\n', argfile);
1914     }
1915   fclose (argfile);
1916
1917   i = system (scmd);
1918
1919   remove (rf);
1920 #endif
1921
1922   if (i == -1)
1923     {
1924       perror_exec (program);
1925       return MIN_FATAL_STATUS << 8;
1926     }
1927   return i << 8;
1928 }
1929
1930 #else /* not __MSDOS__ */
1931
1932 static int
1933 pexecute (search_flag, program, argv, not_last)
1934      int search_flag;
1935      char *program;
1936      char *argv[];
1937      int not_last;
1938 {
1939   int (*func)() = (search_flag ? execv : execvp);
1940   int pid;
1941   int pdes[2];
1942   int input_desc = last_pipe_input;
1943   int output_desc = STDOUT_FILE_NO;
1944   int retries, sleep_interval;
1945
1946   /* If this isn't the last process, make a pipe for its output,
1947      and record it as waiting to be the input to the next process.  */
1948
1949   if (not_last)
1950     {
1951       if (pipe (pdes) < 0)
1952         pfatal_with_name ("pipe");
1953       output_desc = pdes[WRITE_PORT];
1954       last_pipe_input = pdes[READ_PORT];
1955     }
1956   else
1957     last_pipe_input = STDIN_FILE_NO;
1958
1959   /* Fork a subprocess; wait and retry if it fails.  */
1960   sleep_interval = 1;
1961   for (retries = 0; retries < 4; retries++)
1962     {
1963       pid = vfork ();
1964       if (pid >= 0)
1965         break;
1966       sleep (sleep_interval);
1967       sleep_interval *= 2;
1968     }
1969
1970   switch (pid)
1971     {
1972     case -1:
1973 #ifdef vfork
1974       pfatal_with_name ("fork");
1975 #else
1976       pfatal_with_name ("vfork");
1977 #endif
1978       /* NOTREACHED */
1979       return 0;
1980
1981     case 0: /* child */
1982       /* Move the input and output pipes into place, if nec.  */
1983       if (input_desc != STDIN_FILE_NO)
1984         {
1985           close (STDIN_FILE_NO);
1986           dup (input_desc);
1987           close (input_desc);
1988         }
1989       if (output_desc != STDOUT_FILE_NO)
1990         {
1991           close (STDOUT_FILE_NO);
1992           dup (output_desc);
1993           close (output_desc);
1994         }
1995
1996       /* Close the parent's descs that aren't wanted here.  */
1997       if (last_pipe_input != STDIN_FILE_NO)
1998         close (last_pipe_input);
1999
2000       /* Exec the program.  */
2001       (*func) (program, argv);
2002       perror_exec (program);
2003       exit (-1);
2004       /* NOTREACHED */
2005       return 0;
2006
2007     default:
2008       /* In the parent, after forking.
2009          Close the descriptors that we made for this child.  */
2010       if (input_desc != STDIN_FILE_NO)
2011         close (input_desc);
2012       if (output_desc != STDOUT_FILE_NO)
2013         close (output_desc);
2014
2015       /* Return child's process number.  */
2016       return pid;
2017     }
2018 }
2019
2020 #endif /* not __MSDOS__ */
2021 #else /* not OS2 */
2022
2023 static int
2024 pexecute (search_flag, program, argv, not_last)
2025      int search_flag;
2026      char *program;
2027      char *argv[];
2028      int not_last;
2029 {
2030   return (search_flag ? spawnv : spawnvp) (1, program, argv);
2031 }
2032 #endif /* not OS2 */
2033 \f
2034 /* Execute the command specified by the arguments on the current line of spec.
2035    When using pipes, this includes several piped-together commands
2036    with `|' between them.
2037
2038    Return 0 if successful, -1 if failed.  */
2039
2040 static int
2041 execute ()
2042 {
2043   int i;
2044   int n_commands;               /* # of command.  */
2045   char *string;
2046   struct command
2047     {
2048       char *prog;               /* program name.  */
2049       char **argv;              /* vector of args.  */
2050       int pid;                  /* pid of process for this command.  */
2051     };
2052
2053   struct command *commands;     /* each command buffer with above info.  */
2054
2055   /* Count # of piped commands.  */
2056   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2057     if (strcmp (argbuf[i], "|") == 0)
2058       n_commands++;
2059
2060   /* Get storage for each command.  */
2061   commands
2062     = (struct command *) alloca (n_commands * sizeof (struct command));
2063
2064   /* Split argbuf into its separate piped processes,
2065      and record info about each one.
2066      Also search for the programs that are to be run.  */
2067
2068   commands[0].prog = argbuf[0]; /* first command.  */
2069   commands[0].argv = &argbuf[0];
2070   string = find_a_file (&exec_prefix, commands[0].prog, X_OK);
2071   if (string)
2072     commands[0].argv[0] = string;
2073
2074   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2075     if (strcmp (argbuf[i], "|") == 0)
2076       {                         /* each command.  */
2077 #ifdef __MSDOS__
2078         fatal ("-pipe not supported under MS-DOS");
2079 #endif
2080         argbuf[i] = 0;  /* termination of command args.  */
2081         commands[n_commands].prog = argbuf[i + 1];
2082         commands[n_commands].argv = &argbuf[i + 1];
2083         string = find_a_file (&exec_prefix, commands[n_commands].prog, X_OK);
2084         if (string)
2085           commands[n_commands].argv[0] = string;
2086         n_commands++;
2087       }
2088
2089   argbuf[argbuf_index] = 0;
2090
2091   /* If -v, print what we are about to do, and maybe query.  */
2092
2093   if (verbose_flag)
2094     {
2095       /* Print each piped command as a separate line.  */
2096       for (i = 0; i < n_commands ; i++)
2097         {
2098           char **j;
2099
2100           for (j = commands[i].argv; *j; j++)
2101             fprintf (stderr, " %s", *j);
2102
2103           /* Print a pipe symbol after all but the last command.  */
2104           if (i + 1 != n_commands)
2105             fprintf (stderr, " |");
2106           fprintf (stderr, "\n");
2107         }
2108       fflush (stderr);
2109 #ifdef DEBUG
2110       fprintf (stderr, "\nGo ahead? (y or n) ");
2111       fflush (stderr);
2112       i = getchar ();
2113       if (i != '\n')
2114         while (getchar () != '\n') ;
2115       if (i != 'y' && i != 'Y')
2116         return 0;
2117 #endif /* DEBUG */
2118     }
2119
2120   /* Run each piped subprocess.  */
2121
2122   last_pipe_input = STDIN_FILE_NO;
2123   for (i = 0; i < n_commands; i++)
2124     {
2125       char *string = commands[i].argv[0];
2126
2127       commands[i].pid = pexecute (string != commands[i].prog,
2128                                   string, commands[i].argv,
2129                                   i + 1 < n_commands);
2130
2131       if (string != commands[i].prog)
2132         free (string);
2133     }
2134
2135   execution_count++;
2136
2137   /* Wait for all the subprocesses to finish.
2138      We don't care what order they finish in;
2139      we know that N_COMMANDS waits will get them all.  */
2140
2141   {
2142     int ret_code = 0;
2143
2144     for (i = 0; i < n_commands; i++)
2145       {
2146         int status;
2147         int pid;
2148         char *prog = "unknown";
2149
2150 #ifdef __MSDOS__
2151         status = pid = commands[i].pid;
2152 #else
2153         pid = wait (&status);
2154 #endif
2155         if (pid < 0)
2156           abort ();
2157
2158         if (status != 0)
2159           {
2160             int j;
2161             for (j = 0; j < n_commands; j++)
2162               if (commands[j].pid == pid)
2163                 prog = commands[j].prog;
2164
2165             if ((status & 0x7F) != 0)
2166               {
2167                 fatal ("Internal compiler error: program %s got fatal signal %d",
2168                        prog, (status & 0x7F));
2169                 signal_count++;
2170               }
2171             if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
2172               ret_code = -1;
2173           }
2174       }
2175     return ret_code;
2176   }
2177 }
2178 \f
2179 /* Find all the switches given to us
2180    and make a vector describing them.
2181    The elements of the vector are strings, one per switch given.
2182    If a switch uses following arguments, then the `part1' field
2183    is the switch itself and the `args' field
2184    is a null-terminated vector containing the following arguments.
2185    The `live_cond' field is 1 if the switch is true in a conditional spec,
2186    -1 if false (overridden by a later switch), and is initialized to zero.
2187    The `valid' field is nonzero if any spec has looked at this switch;
2188    if it remains zero at the end of the run, it must be meaningless.  */
2189
2190 struct switchstr
2191 {
2192   char *part1;
2193   char **args;
2194   int live_cond;
2195   int valid;
2196 };
2197
2198 static struct switchstr *switches;
2199
2200 static int n_switches;
2201
2202 struct infile
2203 {
2204   char *name;
2205   char *language;
2206 };
2207
2208 /* Also a vector of input files specified.  */
2209
2210 static struct infile *infiles;
2211
2212 static int n_infiles;
2213
2214 /* And a vector of corresponding output files is made up later.  */
2215
2216 static char **outfiles;
2217
2218 /* Create the vector `switches' and its contents.
2219    Store its length in `n_switches'.  */
2220
2221 static void
2222 process_command (argc, argv)
2223      int argc;
2224      char **argv;
2225 {
2226   register int i;
2227   char *temp;
2228   char *spec_lang = 0;
2229   int last_language_n_infiles;
2230
2231   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
2232
2233   n_switches = 0;
2234   n_infiles = 0;
2235
2236   /* Figure compiler version from version string.  */
2237
2238   compiler_version = save_string (version_string, strlen (version_string));
2239   for (temp = compiler_version; *temp; ++temp)
2240     {
2241       if (*temp == ' ')
2242         {
2243           *temp = '\0';
2244           break;
2245         }
2246     }
2247
2248   /* Set up the default search paths.  */
2249
2250   if (gcc_exec_prefix)
2251     {
2252       add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2253       add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2254     }
2255
2256   /* COMPILER_PATH and LIBRARY_PATH have values
2257      that are lists of directory names with colons.  */
2258
2259   temp = getenv ("COMPILER_PATH");
2260   if (temp)
2261     {
2262       char *startp, *endp;
2263       char *nstore = (char *) alloca (strlen (temp) + 3);
2264
2265       startp = endp = temp;
2266       while (1)
2267         {
2268           if (*endp == PATH_SEPARATOR || *endp == 0)
2269             {
2270               strncpy (nstore, startp, endp-startp);
2271               if (endp == startp)
2272                 {
2273                   strcpy (nstore, "./");
2274                 }
2275               else if (endp[-1] != '/')
2276                 {
2277                   nstore[endp-startp] = '/';
2278                   nstore[endp-startp+1] = 0;
2279                 }
2280               else
2281                 nstore[endp-startp] = 0;
2282               add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR);
2283               if (*endp == 0)
2284                 break;
2285               endp = startp = endp + 1;
2286             }
2287           else
2288             endp++;
2289         }
2290     }
2291
2292   temp = getenv ("LIBRARY_PATH");
2293   if (temp)
2294     {
2295       char *startp, *endp;
2296       char *nstore = (char *) alloca (strlen (temp) + 3);
2297
2298       startp = endp = temp;
2299       while (1)
2300         {
2301           if (*endp == PATH_SEPARATOR || *endp == 0)
2302             {
2303               strncpy (nstore, startp, endp-startp);
2304               if (endp == startp)
2305                 {
2306                   strcpy (nstore, "./");
2307                 }
2308               else if (endp[-1] != '/')
2309                 {
2310                   nstore[endp-startp] = '/';
2311                   nstore[endp-startp+1] = 0;
2312                 }
2313               else
2314                 nstore[endp-startp] = 0;
2315               add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2316               if (*endp == 0)
2317                 break;
2318               endp = startp = endp + 1;
2319             }
2320           else
2321             endp++;
2322         }
2323     }
2324
2325   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
2326   temp = getenv ("LPATH");
2327   if (temp)
2328     {
2329       char *startp, *endp;
2330       char *nstore = (char *) alloca (strlen (temp) + 3);
2331
2332       startp = endp = temp;
2333       while (1)
2334         {
2335           if (*endp == PATH_SEPARATOR || *endp == 0)
2336             {
2337               strncpy (nstore, startp, endp-startp);
2338               if (endp == startp)
2339                 {
2340                   strcpy (nstore, "./");
2341                 }
2342               else if (endp[-1] != '/')
2343                 {
2344                   nstore[endp-startp] = '/';
2345                   nstore[endp-startp+1] = 0;
2346                 }
2347               else
2348                 nstore[endp-startp] = 0;
2349               add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2350               if (*endp == 0)
2351                 break;
2352               endp = startp = endp + 1;
2353             }
2354           else
2355             endp++;
2356         }
2357     }
2358
2359   /* Convert new-style -- options to old-style.  */
2360   translate_options (&argc, &argv);
2361
2362   /* Scan argv twice.  Here, the first time, just count how many switches
2363      there will be in their vector, and how many input files in theirs.
2364      Here we also parse the switches that cc itself uses (e.g. -v).  */
2365
2366   for (i = 1; i < argc; i++)
2367     {
2368       if (! strcmp (argv[i], "-dumpspecs"))
2369         {
2370           printf ("*asm:\n%s\n\n", asm_spec);
2371           printf ("*asm_final:\n%s\n\n", asm_final_spec);
2372           printf ("*cpp:\n%s\n\n", cpp_spec);
2373           printf ("*cc1:\n%s\n\n", cc1_spec);
2374           printf ("*cc1plus:\n%s\n\n", cc1plus_spec);
2375           printf ("*endfile:\n%s\n\n", endfile_spec);
2376           printf ("*link:\n%s\n\n", link_spec);
2377           printf ("*lib:\n%s\n\n", lib_spec);
2378           printf ("*startfile:\n%s\n\n", startfile_spec);
2379           printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces);
2380           printf ("*signed_char:\n%s\n\n", signed_char_spec);
2381           printf ("*predefines:\n%s\n\n", cpp_predefines);
2382           printf ("*cross_compile:\n%d\n\n", cross_compile);
2383           printf ("*multilib:\n%s\n\n", multilib_select);
2384
2385           exit (0);
2386         }
2387       else if (! strcmp (argv[i], "-dumpversion"))
2388         {
2389           printf ("%s\n", version_string);
2390           exit (0);
2391         }
2392       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2393           print_file_name = "libgcc.a";
2394       else if (! strncmp (argv[i], "-print-file-name=", 17))
2395           print_file_name = argv[i] + 17;
2396       else if (! strncmp (argv[i], "-print-prog-name=", 17))
2397           print_prog_name = argv[i] + 17;
2398       else if (! strcmp (argv[i], "-print-multi-lib"))
2399         print_multi_lib = 1;
2400       else if (! strcmp (argv[i], "-print-multi-directory"))
2401         print_multi_directory = 1;
2402       else if (! strcmp (argv[i], "-Xlinker"))
2403         {
2404           /* Pass the argument of this option to the linker when we link.  */
2405
2406           if (i + 1 == argc)
2407             fatal ("argument to `-Xlinker' is missing");
2408
2409           n_linker_options++;
2410           if (!linker_options)
2411             linker_options
2412               = (char **) xmalloc (n_linker_options * sizeof (char **));
2413           else
2414             linker_options
2415               = (char **) xrealloc (linker_options,
2416                                     n_linker_options * sizeof (char **));
2417
2418           linker_options[n_linker_options - 1] = argv[++i];
2419         }
2420       else if (! strncmp (argv[i], "-Wl,", 4))
2421         {
2422           int prev, j;
2423           /* Pass the rest of this option to the linker when we link.  */
2424
2425           n_linker_options++;
2426           if (!linker_options)
2427             linker_options
2428               = (char **) xmalloc (n_linker_options * sizeof (char **));
2429           else
2430             linker_options
2431               = (char **) xrealloc (linker_options,
2432                                     n_linker_options * sizeof (char **));
2433
2434           /* Split the argument at commas.  */
2435           prev = 4;
2436           for (j = 4; argv[i][j]; j++)
2437             if (argv[i][j] == ',')
2438               {
2439                 linker_options[n_linker_options - 1]
2440                   = save_string (argv[i] + prev, j - prev);
2441                 n_linker_options++;
2442                 linker_options
2443                   = (char **) xrealloc (linker_options,
2444                                         n_linker_options * sizeof (char **));
2445                 prev = j + 1;
2446               }
2447           /* Record the part after the last comma.  */
2448           linker_options[n_linker_options - 1] = argv[i] + prev;
2449         }
2450       else if (! strncmp (argv[i], "-Wa,", 4))
2451         {
2452           int prev, j;
2453           /* Pass the rest of this option to the assembler.  */
2454
2455           n_assembler_options++;
2456           if (!assembler_options)
2457             assembler_options
2458               = (char **) xmalloc (n_assembler_options * sizeof (char **));
2459           else
2460             assembler_options
2461               = (char **) xrealloc (assembler_options,
2462                                     n_assembler_options * sizeof (char **));
2463
2464           /* Split the argument at commas.  */
2465           prev = 4;
2466           for (j = 4; argv[i][j]; j++)
2467             if (argv[i][j] == ',')
2468               {
2469                 assembler_options[n_assembler_options - 1]
2470                   = save_string (argv[i] + prev, j - prev);
2471                 n_assembler_options++;
2472                 assembler_options
2473                   = (char **) xrealloc (assembler_options,
2474                                         n_assembler_options * sizeof (char **));
2475                 prev = j + 1;
2476               }
2477           /* Record the part after the last comma.  */
2478           assembler_options[n_assembler_options - 1] = argv[i] + prev;
2479         }
2480       else if (argv[i][0] == '+' && argv[i][1] == 'e')
2481         /* The +e options to the C++ front-end.  */
2482         n_switches++;
2483       else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2484         {
2485           register char *p = &argv[i][1];
2486           register int c = *p;
2487
2488           switch (c)
2489             {
2490             case 'b':
2491               if (p[1] == 0 && i + 1 == argc)
2492                 fatal ("argument to `-b' is missing");
2493               if (p[1] == 0)
2494                 spec_machine = argv[++i];
2495               else
2496                 spec_machine = p + 1;
2497               break;
2498
2499             case 'B':
2500               {
2501                 int *temp = (int *) xmalloc (sizeof (int));
2502                 char *value;
2503                 if (p[1] == 0 && i + 1 == argc)
2504                   fatal ("argument to `-B' is missing");
2505                 if (p[1] == 0)
2506                   value = argv[++i];
2507                 else
2508                   value = p + 1;
2509                 add_prefix (&exec_prefix, value, 1, 0, temp);
2510                 add_prefix (&startfile_prefix, value, 1, 0, temp);
2511                 add_prefix (&include_prefix, concat (value, "include", ""),
2512                             1, 0, 0);
2513
2514                 /* As a kludge, if the arg is "[foo/]stageN/", just add
2515                    "[foo/]include" to the include prefix.  */
2516                 {
2517                   int len = strlen (value);
2518                   if ((len == 7 || (len > 7 && value[len - 8] == '/'))
2519                       && strncmp (value + len - 7, "stage", 5) == 0
2520                       && isdigit (value[len - 2])
2521                       && value[len - 1] == '/')
2522                     {
2523                       if (len == 7)
2524                         add_prefix (&include_prefix, "include", 1, 0, 0);
2525                       else
2526                         {
2527                           char *string = xmalloc (len + 1);
2528                           strncpy (string, value, len-7);
2529                           strcat (string, "include");
2530                           add_prefix (&include_prefix, string, 1, 0, 0);
2531                         }
2532                     }
2533                 }
2534               }
2535               break;
2536
2537             case 'v':   /* Print our subcommands and print versions.  */
2538               n_switches++;
2539               /* If they do anything other than exactly `-v', don't set
2540                  verbose_flag; rather, continue on to give the error.  */
2541               if (p[1] != 0)
2542                 break;
2543               verbose_flag++;
2544               break;
2545
2546             case 'V':
2547               if (p[1] == 0 && i + 1 == argc)
2548                 fatal ("argument to `-V' is missing");
2549               if (p[1] == 0)
2550                 spec_version = argv[++i];
2551               else
2552                 spec_version = p + 1;
2553               compiler_version = spec_version;
2554               break;
2555
2556             case 's':
2557               if (!strcmp (p, "save-temps"))
2558                 {
2559                   save_temps_flag = 1;
2560                   n_switches++;
2561                   break;
2562                 }
2563             default:
2564               n_switches++;
2565
2566               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
2567                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
2568               else if (WORD_SWITCH_TAKES_ARG (p))
2569                 i += WORD_SWITCH_TAKES_ARG (p);
2570             }
2571         }
2572       else
2573         n_infiles++;
2574     }
2575
2576   /* Set up the search paths before we go looking for config files.  */
2577
2578   /* These come before the md prefixes so that we will find gcc's subcommands
2579      (such as cpp) rather than those of the host system.  */
2580   /* Use 2 as fourth arg meaning try just the machine as a suffix,
2581      as well as trying the machine and the version.  */
2582   add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
2583   add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
2584
2585   add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
2586   add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
2587
2588   tooldir_prefix = concat (tooldir_base_prefix, spec_machine, "/");
2589
2590   /* If tooldir is relative, base it on exec_prefix.  A relative
2591      tooldir lets us move the installed tree as a unit.
2592
2593      If GCC_EXEC_PREFIX is defined, then we want to add two relative
2594      directories, so that we can search both the user specified directory
2595      and the standard place.  */
2596
2597   if (*tooldir_prefix != '/')
2598     {
2599       if (gcc_exec_prefix)
2600         {
2601           char *gcc_exec_tooldir_prefix
2602             = concat (concat (gcc_exec_prefix, spec_machine, "/"),
2603                       concat (spec_version, "/", tooldir_prefix),
2604                       "");
2605
2606           add_prefix (&exec_prefix, concat (gcc_exec_tooldir_prefix, "bin", "/"),
2607                       0, 0, NULL_PTR);
2608           add_prefix (&startfile_prefix, concat (gcc_exec_tooldir_prefix, "lib", "/"),
2609                       0, 0, NULL_PTR);
2610         }
2611
2612       tooldir_prefix = concat (concat (standard_exec_prefix, spec_machine, "/"),
2613                                concat (spec_version, "/", tooldir_prefix),
2614                                "");
2615     }
2616
2617   add_prefix (&exec_prefix, concat (tooldir_prefix, "bin", "/"),
2618               0, 0, NULL_PTR);
2619   add_prefix (&startfile_prefix, concat (tooldir_prefix, "lib", "/"),
2620               0, 0, NULL_PTR);
2621
2622   /* More prefixes are enabled in main, after we read the specs file
2623      and determine whether this is cross-compilation or not.  */
2624
2625
2626   /* Then create the space for the vectors and scan again.  */
2627
2628   switches = ((struct switchstr *)
2629               xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
2630   infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
2631   n_switches = 0;
2632   n_infiles = 0;
2633   last_language_n_infiles = -1;
2634
2635   /* This, time, copy the text of each switch and store a pointer
2636      to the copy in the vector of switches.
2637      Store all the infiles in their vector.  */
2638
2639   for (i = 1; i < argc; i++)
2640     {
2641       /* Just skip the switches that were handled by the preceding loop.  */
2642       if (!strcmp (argv[i], "-Xlinker"))
2643         i++;
2644       else if (! strncmp (argv[i], "-Wl,", 4))
2645         ;
2646       else if (! strncmp (argv[i], "-Wa,", 4))
2647         ;
2648       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2649         ;
2650       else if (! strncmp (argv[i], "-print-file-name=", 17))
2651         ;
2652       else if (! strncmp (argv[i], "-print-prog-name=", 17))
2653         ;
2654       else if (! strcmp (argv[i], "-print-multi-lib"))
2655         ;
2656       else if (! strcmp (argv[i], "-print-multi-directory"))
2657         ;
2658       else if (argv[i][0] == '+' && argv[i][1] == 'e')
2659         {
2660           /* Compensate for the +e options to the C++ front-end;
2661              they're there simply for cfront call-compatibility.  We do
2662              some magic in default_compilers to pass them down properly.
2663              Note we deliberately start at the `+' here, to avoid passing
2664              -e0 or -e1 down into the linker.  */
2665           switches[n_switches].part1 = &argv[i][0];
2666           switches[n_switches].args = 0;
2667           switches[n_switches].live_cond = 0;
2668           switches[n_switches].valid = 0;
2669           n_switches++;
2670         }
2671       else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2672         {
2673           register char *p = &argv[i][1];
2674           register int c = *p;
2675
2676           if (c == 'B' || c == 'b' || c == 'V')
2677             {
2678               /* Skip a separate arg, if any.  */
2679               if (p[1] == 0)
2680                 i++;
2681               continue;
2682             }
2683           if (c == 'x')
2684             {
2685               if (p[1] == 0 && i + 1 == argc)
2686                 fatal ("argument to `-x' is missing");
2687               if (p[1] == 0)
2688                 spec_lang = argv[++i];
2689               else
2690                 spec_lang = p + 1;
2691               if (! strcmp (spec_lang, "none"))
2692                 /* Suppress the warning if -xnone comes after the last input file,
2693                    because alternate command interfaces like g++ might find it
2694                    useful to place -xnone after each input file.  */
2695                 spec_lang = 0;
2696               else
2697                 last_language_n_infiles = n_infiles;
2698               continue;
2699             }
2700           switches[n_switches].part1 = p;
2701           /* Deal with option arguments in separate argv elements.  */
2702           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
2703               || WORD_SWITCH_TAKES_ARG (p))
2704             {
2705               int j = 0;
2706               int n_args = WORD_SWITCH_TAKES_ARG (p);
2707
2708               if (n_args == 0)
2709                 {
2710                   /* Count only the option arguments in separate argv elements.  */
2711                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
2712                 }
2713               if (i + n_args >= argc)
2714                 fatal ("argument to `-%s' is missing", p);
2715               switches[n_switches].args
2716                 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
2717               while (j < n_args)
2718                 switches[n_switches].args[j++] = argv[++i];
2719               /* Null-terminate the vector.  */
2720               switches[n_switches].args[j] = 0;
2721             }
2722           else if (*switches_need_spaces != 0 && (c == 'o' || c == 'L'))
2723             {
2724               /* On some systems, ld cannot handle -o or -L without space.
2725                  So split the -o or -L from its argument.  */
2726               switches[n_switches].part1 = (c == 'o' ? "o" : "L");
2727               switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
2728               switches[n_switches].args[0] = xmalloc (strlen (p));
2729               strcpy (switches[n_switches].args[0], &p[1]);
2730               switches[n_switches].args[1] = 0;
2731             }
2732           else
2733             switches[n_switches].args = 0;
2734
2735           switches[n_switches].live_cond = 0;
2736           switches[n_switches].valid = 0;
2737           /* This is always valid, since gcc.c itself understands it.  */
2738           if (!strcmp (p, "save-temps"))
2739             switches[n_switches].valid = 1;
2740           n_switches++;
2741         }
2742       else
2743         {
2744           if ((argv[i][0] != '-' || argv[i][1] != 'l')
2745               && strcmp (argv[i], "-")
2746               && access (argv[i], R_OK) < 0)
2747             {
2748               perror_with_name (argv[i]);
2749               error_count++;
2750             }
2751           else
2752             {
2753               infiles[n_infiles].language = spec_lang;
2754               infiles[n_infiles++].name = argv[i];
2755             }
2756         }
2757     }
2758
2759   if (n_infiles == last_language_n_infiles && spec_lang != 0)
2760     error ("Warning: `-x %s' after last input file has no effect", spec_lang);
2761
2762   switches[n_switches].part1 = 0;
2763   infiles[n_infiles].name = 0;
2764
2765   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
2766   if (gcc_exec_prefix)
2767     {
2768       temp = (char *) xmalloc (strlen (gcc_exec_prefix) + strlen (spec_version)
2769                                + strlen (spec_machine) + 3);
2770       strcpy (temp, gcc_exec_prefix);
2771       strcat (temp, spec_machine);
2772       strcat (temp, "/");
2773       strcat (temp, spec_version);
2774       strcat (temp, "/");
2775       gcc_exec_prefix = temp;
2776     }
2777 }
2778 \f
2779 /* Process a spec string, accumulating and running commands.  */
2780
2781 /* These variables describe the input file name.
2782    input_file_number is the index on outfiles of this file,
2783    so that the output file name can be stored for later use by %o.
2784    input_basename is the start of the part of the input file
2785    sans all directory names, and basename_length is the number
2786    of characters starting there excluding the suffix .c or whatever.  */
2787
2788 static char *input_filename;
2789 static int input_file_number;
2790 static int input_filename_length;
2791 static int basename_length;
2792 static char *input_basename;
2793 static char *input_suffix;
2794
2795 /* These are variables used within do_spec and do_spec_1.  */
2796
2797 /* Nonzero if an arg has been started and not yet terminated
2798    (with space, tab or newline).  */
2799 static int arg_going;
2800
2801 /* Nonzero means %d or %g has been seen; the next arg to be terminated
2802    is a temporary file name.  */
2803 static int delete_this_arg;
2804
2805 /* Nonzero means %w has been seen; the next arg to be terminated
2806    is the output file name of this compilation.  */
2807 static int this_is_output_file;
2808
2809 /* Nonzero means %s has been seen; the next arg to be terminated
2810    is the name of a library file and we should try the standard
2811    search dirs for it.  */
2812 static int this_is_library_file;
2813
2814 /* Nonzero means that the input of this command is coming from a pipe.  */
2815 static int input_from_pipe;
2816
2817 /* Process the spec SPEC and run the commands specified therein.
2818    Returns 0 if the spec is successfully processed; -1 if failed.  */
2819
2820 static int
2821 do_spec (spec)
2822      char *spec;
2823 {
2824   int value;
2825
2826   clear_args ();
2827   arg_going = 0;
2828   delete_this_arg = 0;
2829   this_is_output_file = 0;
2830   this_is_library_file = 0;
2831   input_from_pipe = 0;
2832
2833   value = do_spec_1 (spec, 0, NULL_PTR);
2834
2835   /* Force out any unfinished command.
2836      If -pipe, this forces out the last command if it ended in `|'.  */
2837   if (value == 0)
2838     {
2839       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2840         argbuf_index--;
2841
2842       if (argbuf_index > 0)
2843         value = execute ();
2844     }
2845
2846   return value;
2847 }
2848
2849 /* Process the sub-spec SPEC as a portion of a larger spec.
2850    This is like processing a whole spec except that we do
2851    not initialize at the beginning and we do not supply a
2852    newline by default at the end.
2853    INSWITCH nonzero means don't process %-sequences in SPEC;
2854    in this case, % is treated as an ordinary character.
2855    This is used while substituting switches.
2856    INSWITCH nonzero also causes SPC not to terminate an argument.
2857
2858    Value is zero unless a line was finished
2859    and the command on that line reported an error.  */
2860
2861 static int
2862 do_spec_1 (spec, inswitch, soft_matched_part)
2863      char *spec;
2864      int inswitch;
2865      char *soft_matched_part;
2866 {
2867   register char *p = spec;
2868   register int c;
2869   int i;
2870   char *string;
2871   int value;
2872
2873   while (c = *p++)
2874     /* If substituting a switch, treat all chars like letters.
2875        Otherwise, NL, SPC, TAB and % are special.  */
2876     switch (inswitch ? 'a' : c)
2877       {
2878       case '\n':
2879         /* End of line: finish any pending argument,
2880            then run the pending command if one has been started.  */
2881         if (arg_going)
2882           {
2883             obstack_1grow (&obstack, 0);
2884             string = obstack_finish (&obstack);
2885             if (this_is_library_file)
2886               string = find_file (string);
2887             store_arg (string, delete_this_arg, this_is_output_file);
2888             if (this_is_output_file)
2889               outfiles[input_file_number] = string;
2890           }
2891         arg_going = 0;
2892
2893         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2894           {
2895             int i;
2896             for (i = 0; i < n_switches; i++)
2897               if (!strcmp (switches[i].part1, "pipe"))
2898                 break;
2899
2900             /* A `|' before the newline means use a pipe here,
2901                but only if -pipe was specified.
2902                Otherwise, execute now and don't pass the `|' as an arg.  */
2903             if (i < n_switches)
2904               {
2905                 input_from_pipe = 1;
2906                 switches[i].valid = 1;
2907                 break;
2908               }
2909             else
2910               argbuf_index--;
2911           }
2912
2913         if (argbuf_index > 0)
2914           {
2915             value = execute ();
2916             if (value)
2917               return value;
2918           }
2919         /* Reinitialize for a new command, and for a new argument.  */
2920         clear_args ();
2921         arg_going = 0;
2922         delete_this_arg = 0;
2923         this_is_output_file = 0;
2924         this_is_library_file = 0;
2925         input_from_pipe = 0;
2926         break;
2927
2928       case '|':
2929         /* End any pending argument.  */
2930         if (arg_going)
2931           {
2932             obstack_1grow (&obstack, 0);
2933             string = obstack_finish (&obstack);
2934             if (this_is_library_file)
2935               string = find_file (string);
2936             store_arg (string, delete_this_arg, this_is_output_file);
2937             if (this_is_output_file)
2938               outfiles[input_file_number] = string;
2939           }
2940
2941         /* Use pipe */
2942         obstack_1grow (&obstack, c);
2943         arg_going = 1;
2944         break;
2945
2946       case '\t':
2947       case ' ':
2948         /* Space or tab ends an argument if one is pending.  */
2949         if (arg_going)
2950           {
2951             obstack_1grow (&obstack, 0);
2952             string = obstack_finish (&obstack);
2953             if (this_is_library_file)
2954               string = find_file (string);
2955             store_arg (string, delete_this_arg, this_is_output_file);
2956             if (this_is_output_file)
2957               outfiles[input_file_number] = string;
2958           }
2959         /* Reinitialize for a new argument.  */
2960         arg_going = 0;
2961         delete_this_arg = 0;
2962         this_is_output_file = 0;
2963         this_is_library_file = 0;
2964         break;
2965
2966       case '%':
2967         switch (c = *p++)
2968           {
2969           case 0:
2970             fatal ("Invalid specification!  Bug in cc.");
2971
2972           case 'b':
2973             obstack_grow (&obstack, input_basename, basename_length);
2974             arg_going = 1;
2975             break;
2976
2977           case 'd':
2978             delete_this_arg = 2;
2979             break;
2980
2981           /* Dump out the directories specified with LIBRARY_PATH,
2982              followed by the absolute directories
2983              that we search for startfiles.  */
2984           case 'D':
2985             {
2986               struct prefix_list *pl = startfile_prefix.plist;
2987               int bufsize = 100;
2988               char *buffer = (char *) xmalloc (bufsize);
2989               int idx;
2990
2991               for (; pl; pl = pl->next)
2992                 {
2993 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2994                   /* Used on systems which record the specified -L dirs
2995                      and use them to search for dynamic linking.  */
2996                   /* Relative directories always come from -B,
2997                      and it is better not to use them for searching
2998                      at run time.  In particular, stage1 loses  */
2999                   if (pl->prefix[0] != '/')
3000                     continue;
3001 #endif
3002                   /* Try subdirectory if there is one.  */
3003                   if (multilib_dir != NULL)
3004                     {
3005                       if (machine_suffix)
3006                         {
3007                           if (strlen (pl->prefix) + strlen (machine_suffix)
3008                               >= bufsize)
3009                             bufsize = (strlen (pl->prefix)
3010                                        + strlen (machine_suffix)) * 2 + 1;
3011                           buffer = (char *) xrealloc (buffer, bufsize);
3012                           strcpy (buffer, pl->prefix);
3013                           strcat (buffer, machine_suffix);
3014                           if (is_directory (buffer, multilib_dir, 1))
3015                             {
3016                               do_spec_1 ("-L", 0, NULL_PTR);
3017 #ifdef SPACE_AFTER_L_OPTION
3018                               do_spec_1 (" ", 0, NULL_PTR);
3019 #endif
3020                               do_spec_1 (buffer, 1, NULL_PTR);
3021                               do_spec_1 (multilib_dir, 1, NULL_PTR);
3022                               /* Make this a separate argument.  */
3023                               do_spec_1 (" ", 0, NULL_PTR);
3024                             }
3025                         }
3026                       if (!pl->require_machine_suffix)
3027                         {
3028                           if (is_directory (pl->prefix, multilib_dir, 1))
3029                             {
3030                               do_spec_1 ("-L", 0, NULL_PTR);
3031 #ifdef SPACE_AFTER_L_OPTION
3032                               do_spec_1 (" ", 0, NULL_PTR);
3033 #endif
3034                               do_spec_1 (pl->prefix, 1, NULL_PTR);
3035                               do_spec_1 (multilib_dir, 1, NULL_PTR);
3036                               /* Make this a separate argument.  */
3037                               do_spec_1 (" ", 0, NULL_PTR);
3038                             }
3039                         }
3040                     }
3041                   if (machine_suffix)
3042                     {
3043                       if (is_directory (pl->prefix, machine_suffix, 1))
3044                         {
3045                           do_spec_1 ("-L", 0, NULL_PTR);
3046 #ifdef SPACE_AFTER_L_OPTION
3047                           do_spec_1 (" ", 0, NULL_PTR);
3048 #endif
3049                           do_spec_1 (pl->prefix, 1, NULL_PTR);
3050                           /* Remove slash from machine_suffix.  */
3051                           if (strlen (machine_suffix) >= bufsize)
3052                             bufsize = strlen (machine_suffix) * 2 + 1;
3053                           buffer = (char *) xrealloc (buffer, bufsize);
3054                           strcpy (buffer, machine_suffix);
3055                           idx = strlen (buffer);
3056                           if (buffer[idx - 1] == '/')
3057                             buffer[idx - 1] = 0;
3058                           do_spec_1 (buffer, 1, NULL_PTR);
3059                           /* Make this a separate argument.  */
3060                           do_spec_1 (" ", 0, NULL_PTR);
3061                         }
3062                     }
3063                   if (!pl->require_machine_suffix)
3064                     {
3065                       if (is_directory (pl->prefix, "", 1))
3066                         {
3067                           do_spec_1 ("-L", 0, NULL_PTR);
3068 #ifdef SPACE_AFTER_L_OPTION
3069                           do_spec_1 (" ", 0, NULL_PTR);
3070 #endif
3071                           /* Remove slash from pl->prefix.  */
3072                           if (strlen (pl->prefix) >= bufsize)
3073                             bufsize = strlen (pl->prefix) * 2 + 1;
3074                           buffer = (char *) xrealloc (buffer, bufsize);
3075                           strcpy (buffer, pl->prefix);
3076                           idx = strlen (buffer);
3077                           if (buffer[idx - 1] == '/')
3078                             buffer[idx - 1] = 0;
3079                           do_spec_1 (buffer, 1, NULL_PTR);
3080                           /* Make this a separate argument.  */
3081                           do_spec_1 (" ", 0, NULL_PTR);
3082                         }
3083                     }
3084                 }
3085               free (buffer);
3086             }
3087             break;
3088
3089           case 'e':
3090             /* {...:%efoo} means report an error with `foo' as error message
3091                and don't execute any more commands for this file.  */
3092             {
3093               char *q = p;
3094               char *buf;
3095               while (*p != 0 && *p != '\n') p++;
3096               buf = (char *) alloca (p - q + 1);
3097               strncpy (buf, q, p - q);
3098               buf[p - q] = 0;
3099               error ("%s", buf);
3100               return -1;
3101             }
3102             break;
3103
3104           case 'g':
3105           case 'u':
3106           case 'U':
3107             if (save_temps_flag)
3108               {
3109                 obstack_grow (&obstack, input_basename, basename_length);
3110                 delete_this_arg = 0;
3111               }
3112             else
3113               {
3114 #ifdef MKTEMP_EACH_FILE
3115                 /* ??? This has a problem: the total number of
3116                    values mktemp can return is limited.
3117                    That matters for the names of object files.
3118                    In 2.4, do something about that.  */
3119                 struct temp_name *t;
3120                 char *suffix = p;
3121                 while (*p == '.' || isalpha (*p))
3122                   p++;
3123
3124                 /* See if we already have an association of %g/%u/%U and
3125                    suffix.  */
3126                 for (t = temp_names; t; t = t->next)
3127                   if (t->length == p - suffix
3128                       && strncmp (t->suffix, suffix, p - suffix) == 0
3129                       && t->unique == (c != 'g'))
3130                     break;
3131
3132                 /* Make a new association if needed.  %u requires one.  */
3133                 if (t == 0 || c == 'u')
3134                   {
3135                     if (t == 0)
3136                       {
3137                         t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
3138                         t->next = temp_names;
3139                         temp_names = t;
3140                       }
3141                     t->length = p - suffix;
3142                     t->suffix = save_string (suffix, p - suffix);
3143                     t->unique = (c != 'g');
3144                     choose_temp_base ();
3145                     t->filename = temp_filename;
3146                     t->filename_length = temp_filename_length;
3147                   }
3148
3149                 obstack_grow (&obstack, t->filename, t->filename_length);
3150                 delete_this_arg = 1;
3151 #else
3152                 obstack_grow (&obstack, temp_filename, temp_filename_length);
3153                 if (c == 'u' || c == 'U')
3154                   {
3155                     static int unique;
3156                     char buff[9];
3157                     if (c == 'u')
3158                       unique++;
3159                     sprintf (buff, "%d", unique);
3160                     obstack_grow (&obstack, buff, strlen (buff));
3161                   }
3162 #endif
3163                 delete_this_arg = 1;
3164               }
3165             arg_going = 1;
3166             break;
3167
3168           case 'i':
3169             obstack_grow (&obstack, input_filename, input_filename_length);
3170             arg_going = 1;
3171             break;
3172
3173           case 'I':
3174             {
3175               struct prefix_list *pl = include_prefix.plist;
3176
3177               if (gcc_exec_prefix)
3178                 {
3179                   do_spec_1 ("-iprefix", 1, NULL_PTR);
3180                   /* Make this a separate argument.  */
3181                   do_spec_1 (" ", 0, NULL_PTR);
3182                   do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
3183                   do_spec_1 (" ", 0, NULL_PTR);
3184                 }
3185
3186               for (; pl; pl = pl->next)
3187                 {
3188                   do_spec_1 ("-isystem", 1, NULL_PTR);
3189                   /* Make this a separate argument.  */
3190                   do_spec_1 (" ", 0, NULL_PTR);
3191                   do_spec_1 (pl->prefix, 1, NULL_PTR);
3192                   do_spec_1 (" ", 0, NULL_PTR);
3193                 }
3194             }
3195             break;
3196
3197           case 'o':
3198             {
3199               register int f;
3200               for (f = 0; f < n_infiles; f++)
3201                 store_arg (outfiles[f], 0, 0);
3202             }
3203             break;
3204
3205           case 's':
3206             this_is_library_file = 1;
3207             break;
3208
3209           case 'w':
3210             this_is_output_file = 1;
3211             break;
3212
3213           case 'W':
3214             {
3215               int index = argbuf_index;
3216               /* Handle the {...} following the %W.  */
3217               if (*p != '{')
3218                 abort ();
3219               p = handle_braces (p + 1);
3220               if (p == 0)
3221                 return -1;
3222               /* If any args were output, mark the last one for deletion
3223                  on failure.  */
3224               if (argbuf_index != index)
3225                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
3226               break;
3227             }
3228
3229           /* %x{OPTION} records OPTION for %X to output.  */
3230           case 'x':
3231             {
3232               char *p1 = p;
3233               char *string;
3234
3235               /* Skip past the option value and make a copy.  */
3236               if (*p != '{')
3237                 abort ();
3238               while (*p++ != '}')
3239                 ;
3240               string = save_string (p1 + 1, p - p1 - 2);
3241
3242               /* See if we already recorded this option.  */
3243               for (i = 0; i < n_linker_options; i++)
3244                 if (! strcmp (string, linker_options[i]))
3245                   {
3246                     free (string);
3247                     return 0;
3248                   }
3249
3250               /* This option is new; add it.  */
3251               n_linker_options++;
3252               if (!linker_options)
3253                 linker_options
3254                   = (char **) xmalloc (n_linker_options * sizeof (char **));
3255               else
3256                 linker_options
3257                   = (char **) xrealloc (linker_options,
3258                                         n_linker_options * sizeof (char **));
3259
3260               linker_options[n_linker_options - 1] = string;
3261             }
3262             break;
3263
3264           /* Dump out the options accumulated previously using %x,
3265              -Xlinker and -Wl,.  */
3266           case 'X':
3267             for (i = 0; i < n_linker_options; i++)
3268               {
3269                 do_spec_1 (linker_options[i], 1, NULL_PTR);
3270                 /* Make each accumulated option a separate argument.  */
3271                 do_spec_1 (" ", 0, NULL_PTR);
3272               }
3273             break;
3274
3275           /* Dump out the options accumulated previously using -Wa,.  */
3276           case 'Y':
3277             for (i = 0; i < n_assembler_options; i++)
3278               {
3279                 do_spec_1 (assembler_options[i], 1, NULL_PTR);
3280                 /* Make each accumulated option a separate argument.  */
3281                 do_spec_1 (" ", 0, NULL_PTR);
3282               }
3283             break;
3284
3285             /* Here are digits and numbers that just process
3286                a certain constant string as a spec.  */
3287
3288           case '1':
3289             value = do_spec_1 (cc1_spec, 0, NULL_PTR);
3290             if (value != 0)
3291               return value;
3292             break;
3293
3294           case '2':
3295             value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
3296             if (value != 0)
3297               return value;
3298             break;
3299
3300           case 'a':
3301             value = do_spec_1 (asm_spec, 0, NULL_PTR);
3302             if (value != 0)
3303               return value;
3304             break;
3305
3306           case 'A':
3307             value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
3308             if (value != 0)
3309               return value;
3310             break;
3311
3312           case 'c':
3313             value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
3314             if (value != 0)
3315               return value;
3316             break;
3317
3318           case 'C':
3319             value = do_spec_1 (cpp_spec, 0, NULL_PTR);
3320             if (value != 0)
3321               return value;
3322             break;
3323
3324           case 'E':
3325             value = do_spec_1 (endfile_spec, 0, NULL_PTR);
3326             if (value != 0)
3327               return value;
3328             break;
3329
3330           case 'l':
3331             value = do_spec_1 (link_spec, 0, NULL_PTR);
3332             if (value != 0)
3333               return value;
3334             break;
3335
3336           case 'L':
3337             value = do_spec_1 (lib_spec, 0, NULL_PTR);
3338             if (value != 0)
3339               return value;
3340             break;
3341
3342           case 'p':
3343             {
3344               char *x = (char *) alloca (strlen (cpp_predefines) + 1);
3345               char *buf = x;
3346               char *y;
3347
3348               /* Copy all of the -D options in CPP_PREDEFINES into BUF.  */
3349               y = cpp_predefines;
3350               while (*y != 0)
3351                 {
3352                   if (! strncmp (y, "-D", 2))
3353                     /* Copy the whole option.  */
3354                     while (*y && *y != ' ' && *y != '\t')
3355                       *x++ = *y++;
3356                   else if (*y == ' ' || *y == '\t')
3357                     /* Copy whitespace to the result.  */
3358                     *x++ = *y++;
3359                   /* Don't copy other options.  */
3360                   else
3361                     y++;
3362                 }
3363
3364               *x = 0;
3365
3366               value = do_spec_1 (buf, 0, NULL_PTR);
3367               if (value != 0)
3368                 return value;
3369             }
3370             break;
3371
3372           case 'P':
3373             {
3374               char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
3375               char *buf = x;
3376               char *y;
3377
3378               /* Copy all of CPP_PREDEFINES into BUF,
3379                  but put __ after every -D and at the end of each arg.  */
3380               y = cpp_predefines;
3381               while (*y != 0)
3382                 {
3383                   if (! strncmp (y, "-D", 2))
3384                     {
3385                       int flag = 0;
3386
3387                       *x++ = *y++;
3388                       *x++ = *y++;
3389
3390                       if (*y != '_'
3391                           || (*(y+1) != '_' && ! isupper (*(y+1))))
3392                         {
3393                           /* Stick __ at front of macro name.  */
3394                           *x++ = '_';
3395                           *x++ = '_';
3396                           /* Arrange to stick __ at the end as well.  */
3397                           flag = 1;
3398                         }
3399
3400                       /* Copy the macro name.  */
3401                       while (*y && *y != '=' && *y != ' ' && *y != '\t')
3402                         *x++ = *y++;
3403
3404                       if (flag)
3405                         {
3406                           *x++ = '_';
3407                           *x++ = '_';
3408                         }
3409
3410                       /* Copy the value given, if any.  */
3411                       while (*y && *y != ' ' && *y != '\t')
3412                         *x++ = *y++;
3413                     }
3414                   else if (*y == ' ' || *y == '\t')
3415                     /* Copy whitespace to the result.  */
3416                     *x++ = *y++;
3417                   /* Don't copy -A options  */
3418                   else
3419                     y++;
3420                 }
3421               *x++ = ' ';
3422
3423               /* Copy all of CPP_PREDEFINES into BUF,
3424                  but put __ after every -D.  */
3425               y = cpp_predefines;
3426               while (*y != 0)
3427                 {
3428                   if (! strncmp (y, "-D", 2))
3429                     {
3430                       y += 2;
3431
3432                       if (*y != '_'
3433                           || (*(y+1) != '_' && ! isupper (*(y+1))))
3434                         {
3435                           /* Stick -D__ at front of macro name.  */
3436                           *x++ = '-';
3437                           *x++ = 'D';
3438                           *x++ = '_';
3439                           *x++ = '_';
3440
3441                           /* Copy the macro name.  */
3442                           while (*y && *y != '=' && *y != ' ' && *y != '\t')
3443                             *x++ = *y++;
3444
3445                           /* Copy the value given, if any.  */
3446                           while (*y && *y != ' ' && *y != '\t')
3447                             *x++ = *y++;
3448                         }
3449                       else
3450                         {
3451                           /* Do not copy this macro - we have just done it before */
3452                           while (*y && *y != ' ' && *y != '\t')
3453                             y++;
3454                         }
3455                     }
3456                   else if (*y == ' ' || *y == '\t')
3457                     /* Copy whitespace to the result.  */
3458                     *x++ = *y++;
3459                   /* Don't copy -A options  */
3460                   else
3461                     y++;
3462                 }
3463               *x++ = ' ';
3464
3465               /* Copy all of the -A options in CPP_PREDEFINES into BUF.  */
3466               y = cpp_predefines;
3467               while (*y != 0)
3468                 {
3469                   if (! strncmp (y, "-A", 2))
3470                     /* Copy the whole option.  */
3471                     while (*y && *y != ' ' && *y != '\t')
3472                       *x++ = *y++;
3473                   else if (*y == ' ' || *y == '\t')
3474                     /* Copy whitespace to the result.  */
3475                     *x++ = *y++;
3476                   /* Don't copy other options.  */
3477                   else
3478                     y++;
3479                 }
3480
3481               *x = 0;
3482
3483               value = do_spec_1 (buf, 0, NULL_PTR);
3484               if (value != 0)
3485                 return value;
3486             }
3487             break;
3488
3489           case 'S':
3490             value = do_spec_1 (startfile_spec, 0, NULL_PTR);
3491             if (value != 0)
3492               return value;
3493             break;
3494
3495             /* Here we define characters other than letters and digits.  */
3496
3497           case '{':
3498             p = handle_braces (p);
3499             if (p == 0)
3500               return -1;
3501             break;
3502
3503           case '%':
3504             obstack_1grow (&obstack, '%');
3505             break;
3506
3507           case '*':
3508             do_spec_1 (soft_matched_part, 1, NULL_PTR);
3509             do_spec_1 (" ", 0, NULL_PTR);
3510             break;
3511
3512             /* Process a string found as the value of a spec given by name.
3513                This feature allows individual machine descriptions
3514                to add and use their own specs.
3515                %[...] modifies -D options the way %P does;
3516                %(...) uses the spec unmodified.  */
3517           case '(':
3518           case '[':
3519             {
3520               char *name = p;
3521               struct spec_list *sl;
3522               int len;
3523
3524               /* The string after the S/P is the name of a spec that is to be
3525                  processed. */
3526               while (*p && *p != ')' && *p != ']')
3527                 p++;
3528
3529               /* See if it's in the list */
3530               for (len = p - name, sl = specs; sl; sl = sl->next)
3531                 if (strncmp (sl->name, name, len) == 0 && !sl->name[len])
3532                   {
3533                     name = sl->spec;
3534                     break;
3535                   }
3536
3537               if (sl)
3538                 {
3539                   if (c == '(')
3540                     {
3541                       value = do_spec_1 (name, 0, NULL_PTR);
3542                       if (value != 0)
3543                         return value;
3544                     }
3545                   else
3546                     {
3547                       char *x = (char *) alloca (strlen (name) * 2 + 1);
3548                       char *buf = x;
3549                       char *y = name;
3550
3551                       /* Copy all of NAME into BUF, but put __ after
3552                          every -D and at the end of each arg,  */
3553                       while (1)
3554                         {
3555                           if (! strncmp (y, "-D", 2))
3556                             {
3557                               *x++ = '-';
3558                               *x++ = 'D';
3559                               *x++ = '_';
3560                               *x++ = '_';
3561                               y += 2;
3562                             }
3563                           else if (*y == ' ' || *y == 0)
3564                             {
3565                               *x++ = '_';
3566                               *x++ = '_';
3567                               if (*y == 0)
3568                                 break;
3569                               else
3570                                 *x++ = *y++;
3571                             }
3572                           else
3573                             *x++ = *y++;
3574                         }
3575                       *x = 0;
3576
3577                       value = do_spec_1 (buf, 0, NULL_PTR);
3578                       if (value != 0)
3579                         return value;
3580                     }
3581                 }
3582
3583               /* Discard the closing paren or bracket.  */
3584               if (*p)
3585                 p++;
3586             }
3587             break;
3588
3589           case 'v':
3590             {
3591               int c1 = *p++;  /* Select first or second version number.  */
3592               char *v = compiler_version;
3593               char *q, *copy;
3594               /* If desired, advance to second version number.  */
3595               if (c1 == '2')
3596                 {
3597                   /* Set P after the first period.  */
3598                   while (*v != 0 && *v != ' ' && *v != '.')
3599                     v++;
3600                   if (*v == '.')
3601                     v++;
3602                 }
3603               /* Set Q at the next period or at the end.  */
3604               q = v;
3605               while (*q != 0 && *q != ' ' && *q != '.')
3606                 q++;
3607               /* Empty string means zero.  */
3608               if (p == q)
3609                 {
3610                   v = "0";
3611                   q = v + 1;
3612                 }
3613               /* Put that part into the command.  */
3614               obstack_grow (&obstack, v, q - v);
3615               arg_going = 1;
3616             }
3617             break;
3618
3619           case '|':
3620             if (input_from_pipe)
3621               do_spec_1 ("-", 0, NULL_PTR);
3622             break;
3623
3624           default:
3625             abort ();
3626           }
3627         break;
3628
3629       case '\\':
3630         /* Backslash: treat next character as ordinary.  */
3631         c = *p++;
3632
3633         /* fall through */
3634       default:
3635         /* Ordinary character: put it into the current argument.  */
3636         obstack_1grow (&obstack, c);
3637         arg_going = 1;
3638       }
3639
3640   return 0;             /* End of string */
3641 }
3642
3643 /* Return 0 if we call do_spec_1 and that returns -1.  */
3644
3645 static char *
3646 handle_braces (p)
3647      register char *p;
3648 {
3649   register char *q;
3650   char *filter;
3651   int pipe = 0;
3652   int negate = 0;
3653   int suffix = 0;
3654
3655   if (*p == '|')
3656     /* A `|' after the open-brace means,
3657        if the test fails, output a single minus sign rather than nothing.
3658        This is used in %{|!pipe:...}.  */
3659     pipe = 1, ++p;
3660
3661   if (*p == '!')
3662     /* A `!' after the open-brace negates the condition:
3663        succeed if the specified switch is not present.  */
3664     negate = 1, ++p;
3665
3666   if (*p == '.')
3667     /* A `.' after the open-brace means test against the current suffix.  */
3668     {
3669       if (pipe)
3670         abort ();
3671
3672       suffix = 1;
3673       ++p;
3674     }
3675
3676   filter = p;
3677   while (*p != ':' && *p != '}') p++;
3678   if (*p != '}')
3679     {
3680       register int count = 1;
3681       q = p + 1;
3682       while (count > 0)
3683         {
3684           if (*q == '{')
3685             count++;
3686           else if (*q == '}')
3687             count--;
3688           else if (*q == 0)
3689             abort ();
3690           q++;
3691         }
3692     }
3693   else
3694     q = p + 1;
3695
3696   if (suffix)
3697     {
3698       int found = (input_suffix != 0
3699                    && strlen (input_suffix) == p - filter
3700                    && strncmp (input_suffix, filter, p - filter) == 0);
3701
3702       if (p[0] == '}')
3703         abort ();
3704
3705       if (negate != found
3706           && do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3707         return 0;
3708
3709       return q;
3710     }
3711   else if (p[-1] == '*' && p[0] == '}')
3712     {
3713       /* Substitute all matching switches as separate args.  */
3714       register int i;
3715       --p;
3716       for (i = 0; i < n_switches; i++)
3717         if (!strncmp (switches[i].part1, filter, p - filter)
3718             && check_live_switch (i, p - filter))
3719           give_switch (i, 0);
3720     }
3721   else
3722     {
3723       /* Test for presence of the specified switch.  */
3724       register int i;
3725       int present = 0;
3726
3727       /* If name specified ends in *, as in {x*:...},
3728          check for %* and handle that case.  */
3729       if (p[-1] == '*' && !negate)
3730         {
3731           int substitution;
3732           char *r = p;
3733
3734           /* First see whether we have %*.  */
3735           substitution = 0;
3736           while (r < q)
3737             {
3738               if (*r == '%' && r[1] == '*')
3739                 substitution = 1;
3740               r++;
3741             }
3742           /* If we do, handle that case.  */
3743           if (substitution)
3744             {
3745               /* Substitute all matching switches as separate args.
3746                  But do this by substituting for %*
3747                  in the text that follows the colon.  */
3748
3749               unsigned hard_match_len = p - filter - 1;
3750               char *string = save_string (p + 1, q - p - 2);
3751
3752               for (i = 0; i < n_switches; i++)
3753                 if (!strncmp (switches[i].part1, filter, hard_match_len)
3754                     && check_live_switch (i, -1))
3755                   {
3756                     do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
3757                     /* Pass any arguments this switch has.  */
3758                     give_switch (i, 1);
3759                   }
3760
3761               return q;
3762             }
3763         }
3764
3765       /* If name specified ends in *, as in {x*:...},
3766          check for presence of any switch name starting with x.  */
3767       if (p[-1] == '*')
3768         {
3769           for (i = 0; i < n_switches; i++)
3770             {
3771               unsigned hard_match_len = p - filter - 1;
3772
3773               if (!strncmp (switches[i].part1, filter, hard_match_len)
3774                   && check_live_switch (i, hard_match_len))
3775                 {
3776                   present = 1;
3777                 }
3778             }
3779         }
3780       /* Otherwise, check for presence of exact name specified.  */
3781       else
3782         {
3783           for (i = 0; i < n_switches; i++)
3784             {
3785               if (!strncmp (switches[i].part1, filter, p - filter)
3786                   && switches[i].part1[p - filter] == 0
3787                   && check_live_switch (i, -1))
3788                 {
3789                   present = 1;
3790                   break;
3791                 }
3792             }
3793         }
3794
3795       /* If it is as desired (present for %{s...}, absent for %{-s...})
3796          then substitute either the switch or the specified
3797          conditional text.  */
3798       if (present != negate)
3799         {
3800           if (*p == '}')
3801             {
3802               give_switch (i, 0);
3803             }
3804           else
3805             {
3806               if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3807                 return 0;
3808             }
3809         }
3810       else if (pipe)
3811         {
3812           /* Here if a %{|...} conditional fails: output a minus sign,
3813              which means "standard output" or "standard input".  */
3814           do_spec_1 ("-", 0, NULL_PTR);
3815         }
3816     }
3817
3818   return q;
3819 }
3820 \f
3821 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
3822    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
3823    spec, or -1 if either exact match or %* is used.
3824
3825    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
3826    whose value does not begin with "no-" is obsoleted by the same value
3827    with the "no-", similarly for a switch with the "no-" prefix.  */
3828
3829 static int
3830 check_live_switch (switchnum, prefix_length)
3831      int switchnum;
3832      int prefix_length;
3833 {
3834   char *name = switches[switchnum].part1;
3835   int i;
3836
3837   /* In the common case of {<at-most-one-letter>*}, a negating
3838      switch would always match, so ignore that case.  We will just
3839      send the conflicting switches to the compiler phase.  */
3840   if (prefix_length >= 0 && prefix_length <= 1)
3841     return 1;
3842
3843   /* If we already processed this switch and determined if it was
3844      live or not, return our past determination.  */
3845   if (switches[switchnum].live_cond != 0)
3846     return switches[switchnum].live_cond > 0;
3847
3848   /* Now search for duplicate in a manner that depends on the name.  */
3849   switch (*name)
3850     {
3851     case 'O':
3852         for (i = switchnum + 1; i < n_switches; i++)
3853           if (switches[i].part1[0] == 'O')
3854             {
3855               switches[switchnum].valid = 1;
3856               switches[switchnum].live_cond = -1;
3857               return 0;
3858             }
3859       break;
3860
3861     case 'W':  case 'f':  case 'm':
3862       if (! strncmp (name + 1, "no-", 3))
3863         {
3864           /* We have Xno-YYY, search for XYYY. */
3865           for (i = switchnum + 1; i < n_switches; i++)
3866             if (switches[i].part1[0] == name[0]
3867                 && ! strcmp (&switches[i].part1[1], &name[4]))
3868             {
3869               switches[switchnum].valid = 1;
3870               switches[switchnum].live_cond = -1;
3871               return 0;
3872             }
3873         }
3874       else
3875         {
3876           /* We have XYYY, search for Xno-YYY.  */
3877           for (i = switchnum + 1; i < n_switches; i++)
3878             if (switches[i].part1[0] == name[0]
3879                 && switches[i].part1[1] == 'n'
3880                 && switches[i].part1[2] == 'o'
3881                 && switches[i].part1[3] == '-'
3882                 && !strcmp (&switches[i].part1[4], &name[1]))
3883             {
3884               switches[switchnum].valid = 1;
3885               switches[switchnum].live_cond = -1;
3886               return 0;
3887             }
3888         }
3889       break;
3890     }
3891
3892   /* Otherwise the switch is live.  */
3893   switches[switchnum].live_cond = 1;
3894   return 1;
3895 }
3896 \f
3897 /* Pass a switch to the current accumulating command
3898    in the same form that we received it.
3899    SWITCHNUM identifies the switch; it is an index into
3900    the vector of switches gcc received, which is `switches'.
3901    This cannot fail since it never finishes a command line.
3902
3903    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
3904
3905 static void
3906 give_switch (switchnum, omit_first_word)
3907      int switchnum;
3908      int omit_first_word;
3909 {
3910   if (!omit_first_word)
3911     {
3912       do_spec_1 ("-", 0, NULL_PTR);
3913       do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
3914     }
3915   do_spec_1 (" ", 0, NULL_PTR);
3916   if (switches[switchnum].args != 0)
3917     {
3918       char **p;
3919       for (p = switches[switchnum].args; *p; p++)
3920         {
3921           do_spec_1 (*p, 1, NULL_PTR);
3922           do_spec_1 (" ", 0, NULL_PTR);
3923         }
3924     }
3925   switches[switchnum].valid = 1;
3926 }
3927 \f
3928 /* Search for a file named NAME trying various prefixes including the
3929    user's -B prefix and some standard ones.
3930    Return the absolute file name found.  If nothing is found, return NAME.  */
3931
3932 static char *
3933 find_file (name)
3934      char *name;
3935 {
3936   char *newname;
3937
3938   /* Try multilib_dir if it is defined.  */
3939   if (multilib_dir != NULL)
3940     {
3941       char *try;
3942
3943       try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
3944       strcpy (try, multilib_dir);
3945       strcat (try, "/");
3946       strcat (try, name);
3947
3948       newname = find_a_file (&startfile_prefix, try, R_OK);
3949
3950       /* If we don't find it in the multi library dir, then fall
3951          through and look for it in the normal places.  */
3952       if (newname != NULL)
3953         return newname;
3954     }
3955
3956   newname = find_a_file (&startfile_prefix, name, R_OK);
3957   return newname ? newname : name;
3958 }
3959
3960 /* Determine whether a directory exists.  If LINKER, return 0 for
3961    certain fixed names not needed by the linker.  If not LINKER, it is
3962    only important to return 0 if the host machine has a small ARG_MAX
3963    limit.  */
3964
3965 static int
3966 is_directory (path1, path2, linker)
3967      char *path1;
3968      char *path2;
3969      int linker;
3970 {
3971   int len1 = strlen (path1);
3972   int len2 = strlen (path2);
3973   char *path = (char *) alloca (3 + len1 + len2);
3974   char *cp;
3975   struct stat st;
3976
3977 #ifndef SMALL_ARG_MAX
3978   if (! linker)
3979     return 1;
3980 #endif
3981
3982   /* Construct the path from the two parts.  Ensure the string ends with "/.".
3983      The resulting path will be a directory even if the given path is a
3984      symbolic link.  */
3985   bcopy (path1, path, len1);
3986   bcopy (path2, path + len1, len2);
3987   cp = path + len1 + len2;
3988   if (cp[-1] != '/')
3989     *cp++ = '/';
3990   *cp++ = '.';
3991   *cp = '\0';
3992
3993   /* Exclude directories that the linker is known to search.  */
3994   if (linker
3995       && ((cp - path == 6 && strcmp (path, "/lib/.") == 0)
3996           || (cp - path == 10 && strcmp (path, "/usr/lib/.") == 0)))
3997     return 0;
3998
3999   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
4000 }
4001 \f
4002 /* On fatal signals, delete all the temporary files.  */
4003
4004 static void
4005 fatal_error (signum)
4006      int signum;
4007 {
4008   signal (signum, SIG_DFL);
4009   delete_failure_queue ();
4010   delete_temp_files ();
4011   /* Get the same signal again, this time not handled,
4012      so its normal effect occurs.  */
4013   kill (getpid (), signum);
4014 }
4015
4016 int
4017 main (argc, argv)
4018      int argc;
4019      char **argv;
4020 {
4021   register int i;
4022   int j;
4023   int value;
4024   int linker_was_run = 0;
4025   char *explicit_link_files;
4026   char *specs_file;
4027   char *p;
4028
4029   p = argv[0] + strlen (argv[0]);
4030   while (p != argv[0] && p[-1] != '/') --p;
4031   programname = p;
4032
4033   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
4034     signal (SIGINT, fatal_error);
4035 #ifdef SIGHUP
4036   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
4037     signal (SIGHUP, fatal_error);
4038 #endif
4039   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
4040     signal (SIGTERM, fatal_error);
4041 #ifdef SIGPIPE
4042   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
4043     signal (SIGPIPE, fatal_error);
4044 #endif
4045
4046   argbuf_length = 10;
4047   argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
4048
4049   obstack_init (&obstack);
4050
4051   /* Set up to remember the pathname of gcc and any options
4052      needed for collect.  We use argv[0] instead of programname because
4053      we need the complete pathname.  */
4054   obstack_init (&collect_obstack);
4055   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
4056   obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
4057   putenv (obstack_finish (&collect_obstack));
4058
4059   /* Choose directory for temp files.  */
4060
4061   choose_temp_base ();
4062
4063   /* Make a table of what switches there are (switches, n_switches).
4064      Make a table of specified input files (infiles, n_infiles).
4065      Decode switches that are handled locally.  */
4066
4067   process_command (argc, argv);
4068
4069   /* Initialize the vector of specs to just the default.
4070      This means one element containing 0s, as a terminator.  */
4071
4072   compilers = (struct compiler *) xmalloc (sizeof default_compilers);
4073   bcopy ((char *) default_compilers, (char *) compilers,
4074          sizeof default_compilers);
4075   n_compilers = n_default_compilers;
4076
4077   /* Read specs from a file if there is one.  */
4078
4079   machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
4080   just_machine_suffix = concat (spec_machine, "/", "");
4081
4082   specs_file = find_a_file (&startfile_prefix, "specs", R_OK);
4083   /* Read the specs file unless it is a default one.  */
4084   if (specs_file != 0 && strcmp (specs_file, "specs"))
4085     read_specs (specs_file);
4086
4087   /* If not cross-compiling, look for startfiles in the standard places.  */
4088   /* The fact that these are done here, after reading the specs file,
4089      means that it cannot be found in these directories.
4090      But that's okay.  It should never be there anyway.  */
4091   if (!cross_compile)
4092     {
4093 #ifdef MD_EXEC_PREFIX
4094       add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR);
4095       add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR);
4096 #endif
4097
4098 #ifdef MD_STARTFILE_PREFIX
4099       add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR);
4100 #endif
4101
4102 #ifdef MD_STARTFILE_PREFIX_1
4103       add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR);
4104 #endif
4105
4106       /* If standard_startfile_prefix is relative, base it on
4107          standard_exec_prefix.  This lets us move the installed tree
4108          as a unit.  If GCC_EXEC_PREFIX is defined, base
4109          standard_startfile_prefix on that as well.  */
4110       if (*standard_startfile_prefix == '/')
4111         add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0,
4112                     NULL_PTR);
4113       else
4114         {
4115           if (gcc_exec_prefix)
4116             add_prefix (&startfile_prefix,
4117                         concat (gcc_exec_prefix,
4118                                 standard_startfile_prefix,
4119                                 ""),
4120                         0, 0, NULL_PTR);
4121           add_prefix (&startfile_prefix,
4122                       concat (standard_exec_prefix,
4123                               machine_suffix,
4124                               standard_startfile_prefix),
4125                       0, 0, NULL_PTR);
4126         }
4127
4128       add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0,
4129                   NULL_PTR);
4130       add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0,
4131                   NULL_PTR);
4132 #if 0 /* Can cause surprises, and one can use -B./ instead.  */
4133       add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR);
4134 #endif
4135     }
4136
4137   /* Now we have the specs.
4138      Set the `valid' bits for switches that match anything in any spec.  */
4139
4140   validate_all_switches ();
4141
4142   /* Now that we have the switches and the specs, set
4143      the subdirectory based on the options.  */
4144   set_multilib_dir ();
4145
4146   /* Warn about any switches that no pass was interested in.  */
4147
4148   for (i = 0; i < n_switches; i++)
4149     if (! switches[i].valid)
4150       error ("unrecognized option `-%s'", switches[i].part1);
4151
4152   /* Obey some of the options.  */
4153
4154   if (print_file_name)
4155     {
4156       printf ("%s\n", find_file (print_file_name));
4157       exit (0);
4158     }
4159
4160   if (print_prog_name)
4161     {
4162       char *newname = find_a_file (&exec_prefix, print_prog_name, X_OK);
4163       printf ("%s\n", (newname ? newname : print_prog_name));
4164       exit (0);
4165     }
4166
4167   if (print_multi_lib)
4168     {
4169       print_multilib_info ();
4170       exit (0);
4171     }
4172
4173   if (print_multi_directory)
4174     {
4175       if (multilib_dir == NULL)
4176         printf (".\n");
4177       else
4178         printf ("%s\n", multilib_dir);
4179       exit (0);
4180     }
4181
4182   if (verbose_flag)
4183     {
4184       fprintf (stderr, "gcc version %s\n", version_string);
4185       if (n_infiles == 0)
4186         exit (0);
4187     }
4188
4189   if (n_infiles == 0)
4190     fatal ("No input files");
4191
4192   /* Make a place to record the compiler output file names
4193      that correspond to the input files.  */
4194
4195   outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
4196   bzero ((char *) outfiles, n_infiles * sizeof (char *));
4197
4198   /* Record which files were specified explicitly as link input.  */
4199
4200   explicit_link_files = xmalloc (n_infiles);
4201   bzero (explicit_link_files, n_infiles);
4202
4203   for (i = 0; i < n_infiles; i++)
4204     {
4205       register struct compiler *cp = 0;
4206       int this_file_error = 0;
4207
4208       /* Tell do_spec what to substitute for %i.  */
4209
4210       input_filename = infiles[i].name;
4211       input_filename_length = strlen (input_filename);
4212       input_file_number = i;
4213
4214       /* Use the same thing in %o, unless cp->spec says otherwise.  */
4215
4216       outfiles[i] = input_filename;
4217
4218       /* Figure out which compiler from the file's suffix.  */
4219
4220       cp = lookup_compiler (infiles[i].name, input_filename_length,
4221                             infiles[i].language);
4222
4223       if (cp)
4224         {
4225           /* Ok, we found an applicable compiler.  Run its spec.  */
4226           /* First say how much of input_filename to substitute for %b  */
4227           register char *p;
4228           int len;
4229
4230           input_basename = input_filename;
4231           for (p = input_filename; *p; p++)
4232             if (*p == '/')
4233               input_basename = p + 1;
4234
4235           /* Find a suffix starting with the last period,
4236              and set basename_length to exclude that suffix.  */
4237           basename_length = strlen (input_basename);
4238           p = input_basename + basename_length;
4239           while (p != input_basename && *p != '.') --p;
4240           if (*p == '.' && p != input_basename)
4241             {
4242               basename_length = p - input_basename;
4243               input_suffix = p + 1;
4244             }
4245           else
4246             input_suffix = "";
4247
4248           len = 0;
4249           for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
4250             if (cp->spec[j])
4251               len += strlen (cp->spec[j]);
4252
4253           p = (char *) xmalloc (len + 1);
4254
4255           len = 0;
4256           for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
4257             if (cp->spec[j])
4258               {
4259                 strcpy (p + len, cp->spec[j]);
4260                 len += strlen (cp->spec[j]);
4261               }
4262
4263           value = do_spec (p);
4264           free (p);
4265           if (value < 0)
4266             this_file_error = 1;
4267         }
4268
4269       /* If this file's name does not contain a recognized suffix,
4270          record it as explicit linker input.  */
4271
4272       else
4273         explicit_link_files[i] = 1;
4274
4275       /* Clear the delete-on-failure queue, deleting the files in it
4276          if this compilation failed.  */
4277
4278       if (this_file_error)
4279         {
4280           delete_failure_queue ();
4281           error_count++;
4282         }
4283       /* If this compilation succeeded, don't delete those files later.  */
4284       clear_failure_queue ();
4285     }
4286
4287   /* Run ld to link all the compiler output files.  */
4288
4289   if (error_count == 0)
4290     {
4291       int tmp = execution_count;
4292       int i;
4293       int first_time;
4294
4295       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
4296          for collect.  */
4297       putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
4298       putenv_from_prefixes (&startfile_prefix, "LIBRARY_PATH=");
4299
4300       /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4301          the compiler.  */
4302       obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4303                     sizeof ("COLLECT_GCC_OPTIONS=")-1);
4304
4305       first_time = TRUE;
4306       for (i = 0; i < n_switches; i++)
4307         {
4308           char **args;
4309           if (!first_time)
4310             obstack_grow (&collect_obstack, " ", 1);
4311
4312           first_time = FALSE;
4313           obstack_grow (&collect_obstack, "-", 1);
4314           obstack_grow (&collect_obstack, switches[i].part1,
4315                         strlen (switches[i].part1));
4316
4317           for (args = switches[i].args; args && *args; args++)
4318             {
4319               obstack_grow (&collect_obstack, " ", 1);
4320               obstack_grow (&collect_obstack, *args, strlen (*args));
4321             }
4322         }
4323       obstack_grow (&collect_obstack, "\0", 1);
4324       putenv (obstack_finish (&collect_obstack));
4325
4326       value = do_spec (link_command_spec);
4327       if (value < 0)
4328         error_count = 1;
4329       linker_was_run = (tmp != execution_count);
4330     }
4331
4332   /* Warn if a -B option was specified but the prefix was never used.  */
4333   unused_prefix_warnings (&exec_prefix);
4334   unused_prefix_warnings (&startfile_prefix);
4335
4336   /* If options said don't run linker,
4337      complain about input files to be given to the linker.  */
4338
4339   if (! linker_was_run && error_count == 0)
4340     for (i = 0; i < n_infiles; i++)
4341       if (explicit_link_files[i])
4342         error ("%s: linker input file unused since linking not done",
4343                outfiles[i]);
4344
4345   /* Delete some or all of the temporary files we made.  */
4346
4347   if (error_count)
4348     delete_failure_queue ();
4349   delete_temp_files ();
4350
4351   exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
4352   /* NOTREACHED */
4353   return 0;
4354 }
4355
4356 /* Find the proper compilation spec for the file name NAME,
4357    whose length is LENGTH.  LANGUAGE is the specified language,
4358    or 0 if none specified.  */
4359
4360 static struct compiler *
4361 lookup_compiler (name, length, language)
4362      char *name;
4363      int length;
4364      char *language;
4365 {
4366   struct compiler *cp;
4367
4368   /* Look for the language, if one is spec'd.  */
4369   if (language != 0)
4370     {
4371       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4372         {
4373           if (language != 0)
4374             {
4375               if (cp->suffix[0] == '@'
4376                   && !strcmp (cp->suffix + 1, language))
4377                 return cp;
4378             }
4379         }
4380       error ("language %s not recognized", language);
4381     }
4382
4383   /* Look for a suffix.  */
4384   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4385     {
4386       if (/* The suffix `-' matches only the file name `-'.  */
4387           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
4388           ||
4389           (strlen (cp->suffix) < length
4390            /* See if the suffix matches the end of NAME.  */
4391            && !strcmp (cp->suffix,
4392                        name + length - strlen (cp->suffix))))
4393         {
4394           if (cp->spec[0][0] == '@')
4395             {
4396               struct compiler *new;
4397               /* An alias entry maps a suffix to a language.
4398                  Search for the language; pass 0 for NAME and LENGTH
4399                  to avoid infinite recursion if language not found.
4400                  Construct the new compiler spec.  */
4401               language = cp->spec[0] + 1;
4402               new = (struct compiler *) xmalloc (sizeof (struct compiler));
4403               new->suffix = cp->suffix;
4404               bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
4405                      (char *) new->spec, sizeof new->spec);
4406               return new;
4407             }
4408           /* A non-alias entry: return it.  */
4409           return cp;
4410         }
4411     }
4412
4413   return 0;
4414 }
4415 \f
4416 char *
4417 xmalloc (size)
4418      unsigned size;
4419 {
4420   register char *value = (char *) malloc (size);
4421   if (value == 0)
4422     fatal ("virtual memory exhausted");
4423   return value;
4424 }
4425
4426 char *
4427 xrealloc (ptr, size)
4428      char *ptr;
4429      unsigned size;
4430 {
4431   register char *value = (char *) realloc (ptr, size);
4432   if (value == 0)
4433     fatal ("virtual memory exhausted");
4434   return value;
4435 }
4436
4437 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
4438
4439 static char *
4440 concat (s1, s2, s3)
4441      char *s1, *s2, *s3;
4442 {
4443   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
4444   char *result = xmalloc (len1 + len2 + len3 + 1);
4445
4446   strcpy (result, s1);
4447   strcpy (result + len1, s2);
4448   strcpy (result + len1 + len2, s3);
4449   *(result + len1 + len2 + len3) = 0;
4450
4451   return result;
4452 }
4453
4454 static char *
4455 save_string (s, len)
4456      char *s;
4457      int len;
4458 {
4459   register char *result = xmalloc (len + 1);
4460
4461   bcopy (s, result, len);
4462   result[len] = 0;
4463   return result;
4464 }
4465
4466 static void
4467 pfatal_with_name (name)
4468      char *name;
4469 {
4470   char *s;
4471
4472   if (errno < sys_nerr)
4473     s = concat ("%s: ", sys_errlist[errno], "");
4474   else
4475     s = "cannot open %s";
4476   fatal (s, name);
4477 }
4478
4479 static void
4480 perror_with_name (name)
4481      char *name;
4482 {
4483   char *s;
4484
4485   if (errno < sys_nerr)
4486     s = concat ("%s: ", sys_errlist[errno], "");
4487   else
4488     s = "cannot open %s";
4489   error (s, name);
4490 }
4491
4492 static void
4493 perror_exec (name)
4494      char *name;
4495 {
4496   char *s;
4497
4498   if (errno < sys_nerr)
4499     s = concat ("installation problem, cannot exec %s: ",
4500                 sys_errlist[errno], "");
4501   else
4502     s = "installation problem, cannot exec %s";
4503   error (s, name);
4504 }
4505
4506 /* More 'friendly' abort that prints the line and file.
4507    config.h can #define abort fancy_abort if you like that sort of thing.  */
4508
4509 void
4510 fancy_abort ()
4511 {
4512   fatal ("Internal gcc abort.");
4513 }
4514 \f
4515 #ifdef HAVE_VPRINTF
4516
4517 /* Output an error message and exit */
4518
4519 static void
4520 fatal VPROTO((char *format, ...))
4521 {
4522 #ifndef __STDC__
4523   char *format;
4524 #endif
4525   va_list ap;
4526
4527   VA_START (ap, format);
4528
4529 #ifndef __STDC__
4530   format = va_arg (ap, char*);
4531 #endif
4532
4533   fprintf (stderr, "%s: ", programname);
4534   vfprintf (stderr, format, ap);
4535   va_end (ap);
4536   fprintf (stderr, "\n");
4537   delete_temp_files ();
4538   exit (1);
4539 }
4540
4541 static void
4542 error VPROTO((char *format, ...))
4543 {
4544 #ifndef __STDC__
4545   char *format;
4546 #endif
4547   va_list ap;
4548
4549   VA_START (ap, format);
4550
4551 #ifndef __STDC__
4552   format = va_arg (ap, char*);
4553 #endif
4554
4555   fprintf (stderr, "%s: ", programname);
4556   vfprintf (stderr, format, ap);
4557   va_end (ap);
4558
4559   fprintf (stderr, "\n");
4560 }
4561
4562 #else /* not HAVE_VPRINTF */
4563
4564 static void
4565 fatal (msg, arg1, arg2)
4566      char *msg, *arg1, *arg2;
4567 {
4568   error (msg, arg1, arg2);
4569   delete_temp_files ();
4570   exit (1);
4571 }
4572
4573 static void
4574 error (msg, arg1, arg2)
4575      char *msg, *arg1, *arg2;
4576 {
4577   fprintf (stderr, "%s: ", programname);
4578   fprintf (stderr, msg, arg1, arg2);
4579   fprintf (stderr, "\n");
4580 }
4581
4582 #endif /* not HAVE_VPRINTF */
4583
4584 \f
4585 static void
4586 validate_all_switches ()
4587 {
4588   struct compiler *comp;
4589   register char *p;
4590   register char c;
4591   struct spec_list *spec;
4592
4593   for (comp = compilers; comp->spec[0]; comp++)
4594     {
4595       int i;
4596       for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
4597         {
4598           p = comp->spec[i];
4599           while (c = *p++)
4600             if (c == '%' && *p == '{')
4601               /* We have a switch spec.  */
4602               validate_switches (p + 1);
4603         }
4604     }
4605
4606   /* look through the linked list of extra specs read from the specs file */
4607   for (spec = specs; spec ; spec = spec->next)
4608     {
4609       p = spec->spec;
4610       while (c = *p++)
4611         if (c == '%' && *p == '{')
4612           /* We have a switch spec.  */
4613           validate_switches (p + 1);
4614     }
4615
4616   p = link_command_spec;
4617   while (c = *p++)
4618     if (c == '%' && *p == '{')
4619       /* We have a switch spec.  */
4620       validate_switches (p + 1);
4621
4622   /* Now notice switches mentioned in the machine-specific specs.  */
4623
4624   p = asm_spec;
4625   while (c = *p++)
4626     if (c == '%' && *p == '{')
4627       /* We have a switch spec.  */
4628       validate_switches (p + 1);
4629
4630   p = asm_final_spec;
4631   while (c = *p++)
4632     if (c == '%' && *p == '{')
4633       /* We have a switch spec.  */
4634       validate_switches (p + 1);
4635
4636   p = cpp_spec;
4637   while (c = *p++)
4638     if (c == '%' && *p == '{')
4639       /* We have a switch spec.  */
4640       validate_switches (p + 1);
4641
4642   p = signed_char_spec;
4643   while (c = *p++)
4644     if (c == '%' && *p == '{')
4645       /* We have a switch spec.  */
4646       validate_switches (p + 1);
4647
4648   p = cc1_spec;
4649   while (c = *p++)
4650     if (c == '%' && *p == '{')
4651       /* We have a switch spec.  */
4652       validate_switches (p + 1);
4653
4654   p = cc1plus_spec;
4655   while (c = *p++)
4656     if (c == '%' && *p == '{')
4657       /* We have a switch spec.  */
4658       validate_switches (p + 1);
4659
4660   p = link_spec;
4661   while (c = *p++)
4662     if (c == '%' && *p == '{')
4663       /* We have a switch spec.  */
4664       validate_switches (p + 1);
4665
4666   p = lib_spec;
4667   while (c = *p++)
4668     if (c == '%' && *p == '{')
4669       /* We have a switch spec.  */
4670       validate_switches (p + 1);
4671
4672   p = startfile_spec;
4673   while (c = *p++)
4674     if (c == '%' && *p == '{')
4675       /* We have a switch spec.  */
4676       validate_switches (p + 1);
4677 }
4678
4679 /* Look at the switch-name that comes after START
4680    and mark as valid all supplied switches that match it.  */
4681
4682 static void
4683 validate_switches (start)
4684      char *start;
4685 {
4686   register char *p = start;
4687   char *filter;
4688   register int i;
4689   int suffix = 0;
4690
4691   if (*p == '|')
4692     ++p;
4693
4694   if (*p == '!')
4695     ++p;
4696
4697   if (*p == '.')
4698     suffix = 1, ++p;
4699
4700   filter = p;
4701   while (*p != ':' && *p != '}') p++;
4702
4703   if (suffix)
4704     ;
4705   else if (p[-1] == '*')
4706     {
4707       /* Mark all matching switches as valid.  */
4708       --p;
4709       for (i = 0; i < n_switches; i++)
4710         if (!strncmp (switches[i].part1, filter, p - filter))
4711           switches[i].valid = 1;
4712     }
4713   else
4714     {
4715       /* Mark an exact matching switch as valid.  */
4716       for (i = 0; i < n_switches; i++)
4717         {
4718           if (!strncmp (switches[i].part1, filter, p - filter)
4719               && switches[i].part1[p - filter] == 0)
4720             switches[i].valid = 1;
4721         }
4722     }
4723 }
4724 \f
4725 /* Check whether a particular argument was used.  */
4726
4727 static int
4728 used_arg (p, len)
4729      char *p;
4730      int len;
4731 {
4732   int i;
4733
4734   for (i = 0; i < n_switches; i++)
4735     if (! strncmp (switches[i].part1, p, len)
4736         && strlen (switches[i].part1) == len)
4737       return 1;
4738   return 0;
4739 }
4740
4741 /* Work out the subdirectory to use based on the
4742    options.  The format of multilib_select is a list of elements.
4743    Each element is a subdirectory name followed by a list of options
4744    followed by a semicolon.  gcc will consider each line in turn.  If
4745    none of the options beginning with an exclamation point are
4746    present, and all of the other options are present, that
4747    subdirectory will be used.  */
4748
4749 static void
4750 set_multilib_dir ()
4751 {
4752   char *p = multilib_select;
4753   int this_path_len;
4754   char *this_path, *this_arg;
4755   int failed;
4756
4757   while (*p != '\0')
4758     {
4759       /* Ignore newlines.  */
4760       if (*p == '\n')
4761         {
4762           ++p;
4763           continue;
4764         }
4765
4766       /* Get the initial path.  */
4767       this_path = p;
4768       while (*p != ' ')
4769         {
4770           if (*p == '\0')
4771             abort ();
4772           ++p;
4773         }
4774       this_path_len = p - this_path;
4775
4776       /* Check the arguments.  */
4777       failed = 0;
4778       ++p;
4779       while (*p != ';')
4780         {
4781           if (*p == '\0')
4782             abort ();
4783
4784           if (failed)
4785             {
4786               ++p;
4787               continue;
4788             }
4789
4790           this_arg = p;
4791           while (*p != ' ' && *p != ';')
4792             {
4793               if (*p == '\0')
4794                 abort ();
4795               ++p;
4796             }
4797
4798           if (*this_arg == '!')
4799             failed = used_arg (this_arg + 1, p - (this_arg + 1));
4800           else
4801             failed = ! used_arg (this_arg, p - this_arg);
4802
4803           if (*p == ' ')
4804             ++p;
4805         }
4806
4807       if (! failed)
4808         {
4809           if (this_path_len != 1
4810               || this_path[0] != '.')
4811             {
4812               multilib_dir = xmalloc (this_path_len + 1);
4813               strncpy (multilib_dir, this_path, this_path_len);
4814               multilib_dir[this_path_len] = '\0';
4815             }
4816           break;
4817         }
4818
4819       ++p;
4820     }
4821 }
4822
4823 /* Print out the multiple library subdirectory selection
4824    information.  This prints out a series of lines.  Each line looks
4825    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
4826    required.  Only the desired options are printed out, the negative
4827    matches.  The options are print without a leading dash.  There are
4828    no spaces to make it easy to use the information in the shell.
4829    Each subdirectory is printed only once.  This assumes the ordering
4830    generated by the genmultilib script.  */
4831
4832 static void
4833 print_multilib_info ()
4834 {
4835   char *p = multilib_select;
4836   char *last_path, *this_path;
4837   int last_path_len, skip, use_arg;
4838
4839   while (*p != '\0')
4840     {
4841       /* Ignore newlines.  */
4842       if (*p == '\n')
4843         {
4844           ++p;
4845           continue;
4846         }
4847
4848       /* Get the initial path.  */
4849       this_path = p;
4850       while (*p != ' ')
4851         {
4852           if (*p == '\0')
4853             abort ();
4854           ++p;
4855         }
4856
4857       /* If this is a duplicate, skip it.  */
4858       skip = (p - this_path == last_path_len
4859               && ! strncmp (last_path, this_path, last_path_len));
4860
4861       last_path = this_path;
4862       last_path_len = p - this_path;
4863
4864       if (! skip)
4865         {
4866           char *p1;
4867
4868           for (p1 = last_path; p1 < p; p1++)
4869             putchar (*p1);
4870           putchar (';');
4871         }
4872
4873       ++p;
4874       while (*p != ';')
4875         {
4876           int use_arg;
4877
4878           if (*p == '\0')
4879             abort ();
4880
4881           if (skip)
4882             {
4883               ++p;
4884               continue;
4885             }
4886
4887           use_arg = *p != '!';
4888
4889           if (use_arg)
4890             putchar ('@');
4891
4892           while (*p != ' ' && *p != ';')
4893             {
4894               if (*p == '\0')
4895                 abort ();
4896               if (use_arg)
4897                 putchar (*p);
4898               ++p;
4899             }
4900
4901           if (*p == ' ')
4902             ++p;
4903         }
4904
4905       if (! skip)
4906         putchar ('\n');
4907
4908       ++p;
4909     }
4910 }