OSDN Git Service

2008-12-19 Joel Sherrill <joel.sherrill@oarcorp.com>
[pf3gnuchains/gcc-fork.git] / gcc / gcc.c
index a701d2c..5481d0d 100644 (file)
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -1,13 +1,13 @@
 /* Compiler driver program that can handle many languages.
    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
 /* Compiler driver program that can handle many languages.
    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation,
-   Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
@@ -16,12 +16,8 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.
-
-This paragraph is here to try to keep Sun CC from dying.
-The number of chars here seems crucial!!!!  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 /* This program is the user interface to the C compiler and possibly to
 other compilers.  It is used because compilation is a complicated procedure
 
 /* This program is the user interface to the C compiler and possibly to
 other compilers.  It is used because compilation is a complicated procedure
@@ -86,6 +82,7 @@ compilation is specified by a string called a "spec".  */
 #include "prefix.h"
 #include "gcc.h"
 #include "flags.h"
 #include "prefix.h"
 #include "gcc.h"
 #include "flags.h"
+#include "opts.h"
 
 /* By default there is no special suffix for target executables.  */
 /* FIXME: when autoconf is fixed, remove the host check - dj */
 
 /* By default there is no special suffix for target executables.  */
 /* FIXME: when autoconf is fixed, remove the host check - dj */
@@ -126,6 +123,9 @@ static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
 /* Flag set by cppspec.c to 1.  */
 int is_cpp_driver;
 
 /* Flag set by cppspec.c to 1.  */
 int is_cpp_driver;
 
+/* Flag set to nonzero if an @file argument has been supplied to gcc.  */
+static bool at_file_supplied;
+
 /* Flag saying to pass the greatest exit code returned by a sub-process
    to the calling program.  */
 static int pass_exit_codes;
 /* Flag saying to pass the greatest exit code returned by a sub-process
    to the calling program.  */
 static int pass_exit_codes;
@@ -152,6 +152,8 @@ static const char *print_prog_name = NULL;
 
 static int print_multi_directory;
 
 
 static int print_multi_directory;
 
+static int print_sysroot;
+
 /* Flag saying to print the relative path we'd use to
    find OS libraries given the current compiler flags.  */
 
 /* Flag saying to print the relative path we'd use to
    find OS libraries given the current compiler flags.  */
 
@@ -167,6 +169,11 @@ static int print_multi_lib;
 
 static int print_help_list;
 
 
 static int print_help_list;
 
+/* Flag saying to print the sysroot suffix used for searching for
+   headers.  */
+
+static int print_sysroot_headers_suffix;
+
 /* Flag indicating whether we should print the command and arguments */
 
 static int verbose_flag;
 /* Flag indicating whether we should print the command and arguments */
 
 static int verbose_flag;
@@ -178,9 +185,9 @@ static int verbose_flag;
    shell scripts to capture the driver-generated command line.  */
 static int verbose_only_flag;
 
    shell scripts to capture the driver-generated command line.  */
 static int verbose_only_flag;
 
-/* Flag indicating to print target specific command line options.  */
+/* Flag indicating how to print command line options of sub-processes.  */
 
 
-static int target_help_flag;
+static int print_subprocess_help;
 
 /* Flag indicating whether we should report subprocess execution times
    (if this is supported by the system - see pexecute.c).  */
 
 /* Flag indicating whether we should report subprocess execution times
    (if this is supported by the system - see pexecute.c).  */
@@ -237,7 +244,7 @@ static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 /* Nonzero if cross-compiling.
    When -b is used, the value comes from the `specs' file.  */
 
 /* Nonzero if cross-compiling.
    When -b is used, the value comes from the `specs' file.  */
 
-#ifdef CROSS_COMPILE
+#ifdef CROSS_DIRECTORY_STRUCTURE
 static const char *cross_compile = "1";
 #else
 static const char *cross_compile = "0";
 static const char *cross_compile = "1";
 #else
 static const char *cross_compile = "0";
@@ -277,20 +284,32 @@ static struct obstack obstack;
 
 static struct obstack collect_obstack;
 
 
 static struct obstack collect_obstack;
 
+/* This is a list of a wrapper program and its arguments.
+   e.g. wrapper_string of "strace,-c"
+   will cause all programs to run as
+       strace -c program arguments
+   instead of just
+       program arguments */
+static const char  *wrapper_string;
+
 /* Forward declaration for prototypes.  */
 struct path_prefix;
 struct prefix_list;
 
 static void init_spec (void);
 static void store_arg (const char *, int, int);
 /* Forward declaration for prototypes.  */
 struct path_prefix;
 struct prefix_list;
 
 static void init_spec (void);
 static void store_arg (const char *, int, int);
+static void insert_wrapper (const char *);
 static char *load_specs (const char *);
 static void read_specs (const char *, int);
 static void set_spec (const char *, const char *);
 static struct compiler *lookup_compiler (const char *, size_t, const char *);
 static char *load_specs (const char *);
 static void read_specs (const char *, int);
 static void set_spec (const char *, const char *);
 static struct compiler *lookup_compiler (const char *, size_t, const char *);
-static char *build_search_list (struct path_prefix *, const char *, int);
-static void putenv_from_prefixes (struct path_prefix *, const char *);
+static char *build_search_list (const struct path_prefix *, const char *,
+                               bool, bool);
+static void xputenv (const char *);
+static void putenv_from_prefixes (const struct path_prefix *, const char *,
+                                 bool);
 static int access_check (const char *, int);
 static int access_check (const char *, int);
-static char *find_a_file (struct path_prefix *, const char *, int, int);
+static char *find_a_file (const struct path_prefix *, const char *, int, bool);
 static void add_prefix (struct path_prefix *, const char *, const char *,
                        int, int, int);
 static void add_sysrooted_prefix (struct path_prefix *, const char *,
 static void add_prefix (struct path_prefix *, const char *, const char *,
                        int, int, int);
 static void add_sysrooted_prefix (struct path_prefix *, const char *,
@@ -313,13 +332,12 @@ static const char *eval_spec_function (const char *, const char *);
 static const char *handle_spec_function (const char *);
 static char *save_string (const char *, int);
 static void set_collect_gcc_options (void);
 static const char *handle_spec_function (const char *);
 static char *save_string (const char *, int);
 static void set_collect_gcc_options (void);
-static void do_spec_path (struct prefix_list *, const char *, int, int, int, const char *, const char *);
 static int do_spec_1 (const char *, int, const char *);
 static int do_spec_2 (const char *);
 static void do_option_spec (const char *, const char *);
 static void do_self_spec (const char *);
 static const char *find_file (const char *);
 static int do_spec_1 (const char *, int, const char *);
 static int do_spec_2 (const char *);
 static void do_option_spec (const char *, const char *);
 static void do_self_spec (const char *);
 static const char *find_file (const char *);
-static int is_directory (const char *, const char *, int);
+static int is_directory (const char *, bool);
 static const char *validate_switches (const char *);
 static void validate_all_switches (void);
 static inline void validate_switches_from_spec (const char *);
 static const char *validate_switches (const char *);
 static void validate_all_switches (void);
 static inline void validate_switches_from_spec (const char *);
@@ -329,6 +347,7 @@ static int default_arg (const char *, int);
 static void set_multilib_dir (void);
 static void print_multilib_info (void);
 static void perror_with_name (const char *);
 static void set_multilib_dir (void);
 static void print_multilib_info (void);
 static void perror_with_name (const char *);
+static void fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
 static void display_help (void);
 static void add_preprocessor_option (const char *, int);
 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
 static void display_help (void);
 static void add_preprocessor_option (const char *, int);
@@ -347,10 +366,13 @@ static void init_gcc_specs (struct obstack *, const char *, const char *,
 static const char *convert_filename (const char *, int, int);
 #endif
 
 static const char *convert_filename (const char *, int, int);
 #endif
 
+static const char *getenv_spec_function (int, const char **);
 static const char *if_exists_spec_function (int, const char **);
 static const char *if_exists_else_spec_function (int, const char **);
 static const char *replace_outfile_spec_function (int, const char **);
 static const char *version_compare_spec_function (int, const char **);
 static const char *if_exists_spec_function (int, const char **);
 static const char *if_exists_else_spec_function (int, const char **);
 static const char *replace_outfile_spec_function (int, const char **);
 static const char *version_compare_spec_function (int, const char **);
+static const char *include_spec_function (int, const char **);
+static const char *print_asm_header_spec_function (int, const char **);
 \f
 /* The Specs Language
 
 \f
 /* The Specs Language
 
@@ -380,7 +402,7 @@ or with constant text in a single argument.
        chosen in a way that is hard to predict even when previously
        chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
        might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
        chosen in a way that is hard to predict even when previously
        chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
        might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
-       the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
+       the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
        had been pre-processed.  Previously, %g was simply substituted
        with a file name chosen once per compilation, without regard
        to any appended suffix (which was therefore treated just like
        had been pre-processed.  Previously, %g was simply substituted
        with a file name chosen once per compilation, without regard
        to any appended suffix (which was therefore treated just like
@@ -439,8 +461,8 @@ or with constant text in a single argument.
        SUFFIX characters following %O as they would following, for
        example, `.o'.
  %I    Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
        SUFFIX characters following %O as they would following, for
        example, `.o'.
  %I    Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
-       (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
-       and -B options) as necessary.
+       (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
+       and -B options) and -imultilib as necessary.
  %s     current argument is the name of a library or startup file of some sort.
         Search for that file in a standard list of directories
        and substitute the full name found.
  %s     current argument is the name of a library or startup file of some sort.
         Search for that file in a standard list of directories
        and substitute the full name found.
@@ -506,15 +528,18 @@ or with constant text in a single argument.
           part of that switch that matched the '*'.
  %{.S:X}  substitutes X, if processing a file with suffix S.
  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
           part of that switch that matched the '*'.
  %{.S:X}  substitutes X, if processing a file with suffix S.
  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
-
+ %{,S:X}  substitutes X, if processing a file which will use spec S.
+ %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
+         
  %{S|T:X} substitutes X if either -S or -T was given to CC.  This may be
  %{S|T:X} substitutes X if either -S or -T was given to CC.  This may be
-         combined with !, ., and * as above binding stronger than the OR.
+         combined with '!', '.', ',', and '*' as above binding stronger
+         than the OR.
          If %* appears in X, all of the alternatives must be starred, and
          only the first matching alternative is substituted.
  %{S:X;   if S was given to CC, substitutes X;
    T:Y;   else if T was given to CC, substitutes Y;
     :D}   else substitutes D.  There can be as many clauses as you need.
          If %* appears in X, all of the alternatives must be starred, and
          only the first matching alternative is substituted.
  %{S:X;   if S was given to CC, substitutes X;
    T:Y;   else if T was given to CC, substitutes Y;
     :D}   else substitutes D.  There can be as many clauses as you need.
-          This may be combined with ., !, |, and * as above.
+          This may be combined with '.', '!', ',', '|', and '*' as above.
 
  %(Spec) processes a specification defined in a specs file as *Spec:
  %[Spec] as above, but put __ around -D arguments
 
  %(Spec) processes a specification defined in a specs file as *Spec:
  %[Spec] as above, but put __ around -D arguments
@@ -602,7 +627,7 @@ proper position among the other output files.  */
 }} %{fmudflap|fmudflapth: --wrap=main}"
 #endif
 #ifndef MFLIB_SPEC
 }} %{fmudflap|fmudflapth: --wrap=main}"
 #endif
 #ifndef MFLIB_SPEC
-#define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}" 
+#define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
 #endif
 
 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
 #endif
 
 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
@@ -639,21 +664,27 @@ proper position among the other output files.  */
 #define LINKER_NAME "collect2"
 #endif
 
 #define LINKER_NAME "collect2"
 #endif
 
+#ifdef HAVE_AS_DEBUG_PREFIX_MAP
+#define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
+#else
+#define ASM_MAP ""
+#endif
+
 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
    to the assembler.  */
 #ifndef ASM_DEBUG_SPEC
 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
    to the assembler.  */
 #ifndef ASM_DEBUG_SPEC
 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
-#  define ASM_DEBUG_SPEC                                       \
-      (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                   \
-       ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}"  \
-       : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
+#  define ASM_DEBUG_SPEC                                               \
+      (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                           \
+       ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" ASM_MAP  \
+       : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}" ASM_MAP)
 # else
 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 # else
 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
-#   define ASM_DEBUG_SPEC "%{g*:--gstabs}"
+#   define ASM_DEBUG_SPEC "%{g*:--gstabs}" ASM_MAP
 #  endif
 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
 #  endif
 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
-#   define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
+#   define ASM_DEBUG_SPEC "%{g*:--gdwarf2}" ASM_MAP
 #  endif
 # endif
 #endif
 #  endif
 # endif
 #endif
@@ -674,7 +705,7 @@ proper position among the other output files.  */
 #ifdef TARGET_LIBC_PROVIDES_SSP
 #define LINK_SSP_SPEC "%{fstack-protector:}"
 #else
 #ifdef TARGET_LIBC_PROVIDES_SSP
 #define LINK_SSP_SPEC "%{fstack-protector:}"
 #else
-#define LINK_SSP_SPEC "%{fstack-protector:-lssp_nonshared -lssp }"
+#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
 #endif
 #endif
 
 #endif
 #endif
 
@@ -697,9 +728,10 @@ proper position among the other output files.  */
 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
     %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
     %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
     %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
     %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
-    %{static:} %{L*} %(mfwrap) %(link_libgcc) %o %(mflib)\
+    %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
+    %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
     %{fprofile-arcs|fprofile-generate|coverage:-lgcov}\
     %{fprofile-arcs|fprofile-generate|coverage:-lgcov}\
-    %{!nostdlib:%{!nodefaultlibs:%(link_ssp)%(link_gcc_c_sequence)}}\
+    %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
     %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
 #endif
 
     %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
 #endif
 
@@ -736,6 +768,7 @@ static const char *link_spec = LINK_SPEC;
 static const char *lib_spec = LIB_SPEC;
 static const char *mfwrap_spec = MFWRAP_SPEC;
 static const char *mflib_spec = MFLIB_SPEC;
 static const char *lib_spec = LIB_SPEC;
 static const char *mfwrap_spec = MFWRAP_SPEC;
 static const char *mflib_spec = MFLIB_SPEC;
+static const char *link_gomp_spec = "";
 static const char *libgcc_spec = LIBGCC_SPEC;
 static const char *endfile_spec = ENDFILE_SPEC;
 static const char *startfile_spec = STARTFILE_SPEC;
 static const char *libgcc_spec = LIBGCC_SPEC;
 static const char *endfile_spec = ENDFILE_SPEC;
 static const char *startfile_spec = STARTFILE_SPEC;
@@ -769,8 +802,9 @@ static const char *cpp_unique_options =
  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
- %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
- %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
+ %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
+ %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
+ %{H} %C %{D*&U*&A*} %{i*} %Z %i\
  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
  %{E|M|MM:%W{o*}}";
  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
  %{E|M|MM:%W{o*}}";
@@ -782,14 +816,14 @@ static const char *cpp_unique_options =
    in turn cause preprocessor symbols to be defined specially.  */
 static const char *cpp_options =
 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
    in turn cause preprocessor symbols to be defined specially.  */
 static const char *cpp_options =
 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
- %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
+ %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
  %{undef} %{save-temps:-fpch-preprocess}";
 
 /* This contains cpp options which are not passed when the preprocessor
    output will be used by another program.  */
 static const char *cpp_debug_options = "%{d*}";
 
  %{undef} %{save-temps:-fpch-preprocess}";
 
 /* This contains cpp options which are not passed when the preprocessor
    output will be used by another program.  */
 static const char *cpp_debug_options = "%{d*}";
 
-/* NB: This is shared amongst all front-ends.  */
+/* NB: This is shared amongst all front-ends, except for Ada.  */
 static const char *cc1_options =
 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
 static const char *cc1_options =
 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
@@ -798,12 +832,19 @@ static const char *cc1_options =
  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
  %{Qn:-fno-ident} %{--help:--help}\
  %{--target-help:--target-help}\
  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
  %{Qn:-fno-ident} %{--help:--help}\
  %{--target-help:--target-help}\
+ %{--help=*:--help=%(VALUE)}\
  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
  %{fsyntax-only:-o %j} %{-param*}\
  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
  %{coverage:-fprofile-arcs -ftest-coverage}";
 
 static const char *asm_options =
  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
  %{fsyntax-only:-o %j} %{-param*}\
  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
  %{coverage:-fprofile-arcs -ftest-coverage}";
 
 static const char *asm_options =
+"%{--target-help:%:print-asm-header()} "
+#if HAVE_GNU_AS
+/* If GNU AS is used, then convert -w (no warnings), -I, and -v
+   to the assembler equivalents.  */
+"%{v} %{w:-W} %{I*} "
+#endif
 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
 
 static const char *invoke_as =
 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
 
 static const char *invoke_as =
@@ -834,7 +875,15 @@ static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
 #define DRIVER_SELF_SPECS ""
 #endif
 
 #define DRIVER_SELF_SPECS ""
 #endif
 
-static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
+/* Adding -fopenmp should imply pthreads.  This is particularly important
+   for targets that use different start files and suchlike.  */
+#ifndef GOMP_SELF_SPECS
+#define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
+#endif
+
+static const char *const driver_self_specs[] = {
+  DRIVER_SELF_SPECS, GOMP_SELF_SPECS
+};
 
 #ifndef OPTION_DEFAULT_SPECS
 #define OPTION_DEFAULT_SPECS { "", "" }
 
 #ifndef OPTION_DEFAULT_SPECS
 #define OPTION_DEFAULT_SPECS { "", "" }
@@ -920,17 +969,19 @@ static const struct compiler default_compilers[] =
   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
   {".mii", "#Objective-C++", 0, 0, 0},
   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
   {".mii", "#Objective-C++", 0, 0, 0},
-  {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0}, 
-  {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0}, 
+  {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
+  {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
-  {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0}, 
-  {".F", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
-  {".FPP", "#Fortran", 0, 0, 0},
-  {".f90", "#Fortran 95", 0, 0, 0}, {".f95", "#Fortran 95", 0, 0, 0},
-  {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0}, 
-  {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
+  {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
+  {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
+  {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
+  {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
+  {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
+  {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
+  {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
+  {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
   {".r", "#Ratfor", 0, 0, 0},
   {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
   {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
   {".r", "#Ratfor", 0, 0, 0},
   {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
   {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
@@ -983,15 +1034,16 @@ static const struct compiler default_compilers[] =
   {".s", "@assembler", 0, 1, 0},
   {"@assembler",
    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
   {".s", "@assembler", 0, 1, 0},
   {"@assembler",
    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
+  {".sx", "@assembler-with-cpp", 0, 1, 0},
   {".S", "@assembler-with-cpp", 0, 1, 0},
   {"@assembler-with-cpp",
 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
   {".S", "@assembler-with-cpp", 0, 1, 0},
   {"@assembler-with-cpp",
 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
-   "%(trad_capable_cpp) -lang-asm %(cpp_options)\
+   "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
       %{E|M|MM:%(cpp_debug_options)}\
       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
        as %(asm_debug) %(asm_options) %|.s %A }}}}"
 #else
       %{E|M|MM:%(cpp_debug_options)}\
       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
        as %(asm_debug) %(asm_options) %|.s %A }}}}"
 #else
-   "%(trad_capable_cpp) -lang-asm %(cpp_options)\
+   "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
       %{E|M|MM:%(cpp_debug_options)}\
       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
        as %(asm_debug) %(asm_options) %m.s %A }}}}"
       %{E|M|MM:%(cpp_debug_options)}\
       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
        as %(asm_debug) %(asm_options) %m.s %A }}}}"
@@ -1109,6 +1161,8 @@ static const struct option_map option_map[] =
    {"--print-multi-directory", "-print-multi-directory", 0},
    {"--print-multi-os-directory", "-print-multi-os-directory", 0},
    {"--print-prog-name", "-print-prog-name=", "aj"},
    {"--print-multi-directory", "-print-multi-directory", 0},
    {"--print-multi-os-directory", "-print-multi-os-directory", 0},
    {"--print-prog-name", "-print-prog-name=", "aj"},
+   {"--print-sysroot", "-print-sysroot", 0},
+   {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
    {"--profile", "-p", 0},
    {"--profile-blocks", "-a", 0},
    {"--quiet", "-q", 0},
    {"--profile", "-p", 0},
    {"--profile-blocks", "-a", 0},
    {"--quiet", "-q", 0},
@@ -1120,6 +1174,7 @@ static const struct option_map option_map[] =
    {"--static", "-static", 0},
    {"--std", "-std=", "aj"},
    {"--symbolic", "-symbolic", 0},
    {"--static", "-static", 0},
    {"--std", "-std=", "aj"},
    {"--symbolic", "-symbolic", 0},
+   {"--sysroot", "--sysroot=", "aj"},
    {"--time", "-time", 0},
    {"--trace-includes", "-H", 0},
    {"--traditional", "-traditional", 0},
    {"--time", "-time", 0},
    {"--trace-includes", "-H", 0},
    {"--traditional", "-traditional", 0},
@@ -1148,7 +1203,7 @@ static const struct {
 
 /* Translate the options described by *ARGCP and *ARGVP.
    Make a new vector and store it back in *ARGVP,
 
 /* Translate the options described by *ARGCP and *ARGVP.
    Make a new vector and store it back in *ARGVP,
-   and store its length in *ARGVC.  */
+   and store its length in *ARGCP.  */
 
 static void
 translate_options (int *argcp, const char *const **argvp)
 
 static void
 translate_options (int *argcp, const char *const **argvp)
@@ -1157,7 +1212,7 @@ translate_options (int *argcp, const char *const **argvp)
   int argc = *argcp;
   const char *const *argv = *argvp;
   int newvsize = (argc + 2) * 2 * sizeof (const char *);
   int argc = *argcp;
   const char *const *argv = *argvp;
   int newvsize = (argc + 2) * 2 * sizeof (const char *);
-  const char **newv = xmalloc (newvsize);
+  const char **newv = XNEWVAR (const char *, newvsize);
   int newindex = 0;
 
   i = 0;
   int newindex = 0;
 
   i = 0;
@@ -1187,7 +1242,7 @@ translate_options (int *argcp, const char *const **argvp)
                }
 
              newvsize += spaces * sizeof (const char *);
                }
 
              newvsize += spaces * sizeof (const char *);
-             newv =  xrealloc (newv, newvsize);
+             newv =  XRESIZEVAR (const char *, newv, newvsize);
 
              sp = target_option_translations[tott_idx].replacements;
              np = xstrdup (sp);
 
              sp = target_option_translations[tott_idx].replacements;
              np = xstrdup (sp);
@@ -1440,8 +1495,8 @@ static const char *gcc_libexec_prefix;
 #ifndef STANDARD_STARTFILE_PREFIX_2
 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
 #endif
 #ifndef STANDARD_STARTFILE_PREFIX_2
 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
 #endif
-#ifdef CROSS_COMPILE  /* Don't use these prefixes for a cross compiler.  */
+
+#ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
 #undef MD_EXEC_PREFIX
 #undef MD_STARTFILE_PREFIX
 #undef MD_STARTFILE_PREFIX_1
 #undef MD_EXEC_PREFIX
 #undef MD_STARTFILE_PREFIX
 #undef MD_STARTFILE_PREFIX_1
@@ -1458,25 +1513,33 @@ static const char *gcc_libexec_prefix;
 #define MD_STARTFILE_PREFIX_1 ""
 #endif
 
 #define MD_STARTFILE_PREFIX_1 ""
 #endif
 
+/* These directories are locations set at configure-time based on the
+   --prefix option provided to configure.  Their initializers are
+   defined in Makefile.in.  These paths are not *directly* used when
+   gcc_exec_prefix is set because, in that case, we know where the
+   compiler has been installed, and use paths relative to that
+   location instead.  */
 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
+static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
+static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
+static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
+
+/* For native compilers, these are well-known paths containing
+   components that may be provided by the system.  For cross
+   compilers, these paths are not used.  */
 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
 static const char *md_exec_prefix = MD_EXEC_PREFIX;
 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
 static const char *md_exec_prefix = MD_EXEC_PREFIX;
-
 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
-static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
 static const char *const standard_startfile_prefix_1
   = STANDARD_STARTFILE_PREFIX_1;
 static const char *const standard_startfile_prefix_2
   = STANDARD_STARTFILE_PREFIX_2;
 
 static const char *const standard_startfile_prefix_1
   = STANDARD_STARTFILE_PREFIX_1;
 static const char *const standard_startfile_prefix_2
   = STANDARD_STARTFILE_PREFIX_2;
 
+/* A relative path to be used in finding the location of tools
+   relative to the driver.  */
 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
-static const char *tooldir_prefix;
-
-static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
-
-static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
 
 /* Subdirectory to use for locating libraries.  Set by
    set_multilib_dir based on the compilation options.  */
 
 /* Subdirectory to use for locating libraries.  Set by
    set_multilib_dir based on the compilation options.  */
@@ -1533,6 +1596,7 @@ static struct spec_list static_specs[] =
   INIT_STATIC_SPEC ("lib",                     &lib_spec),
   INIT_STATIC_SPEC ("mfwrap",                  &mfwrap_spec),
   INIT_STATIC_SPEC ("mflib",                   &mflib_spec),
   INIT_STATIC_SPEC ("lib",                     &lib_spec),
   INIT_STATIC_SPEC ("mfwrap",                  &mfwrap_spec),
   INIT_STATIC_SPEC ("mflib",                   &mflib_spec),
+  INIT_STATIC_SPEC ("link_gomp",               &link_gomp_spec),
   INIT_STATIC_SPEC ("libgcc",                  &libgcc_spec),
   INIT_STATIC_SPEC ("startfile",               &startfile_spec),
   INIT_STATIC_SPEC ("switches_need_spaces",    &switches_need_spaces),
   INIT_STATIC_SPEC ("libgcc",                  &libgcc_spec),
   INIT_STATIC_SPEC ("startfile",               &startfile_spec),
   INIT_STATIC_SPEC ("switches_need_spaces",    &switches_need_spaces),
@@ -1576,10 +1640,16 @@ static struct spec_list *specs = (struct spec_list *) 0;
 
 static const struct spec_function static_spec_functions[] =
 {
 
 static const struct spec_function static_spec_functions[] =
 {
+  { "getenv",                   getenv_spec_function },
   { "if-exists",               if_exists_spec_function },
   { "if-exists-else",          if_exists_else_spec_function },
   { "replace-outfile",         replace_outfile_spec_function },
   { "version-compare",         version_compare_spec_function },
   { "if-exists",               if_exists_spec_function },
   { "if-exists-else",          if_exists_else_spec_function },
   { "replace-outfile",         replace_outfile_spec_function },
   { "version-compare",         version_compare_spec_function },
+  { "include",                 include_spec_function },
+  { "print-asm-header",                print_asm_header_spec_function },
+#ifdef EXTRA_SPEC_FUNCTIONS
+  EXTRA_SPEC_FUNCTIONS
+#endif
   { 0, 0 }
 };
 
   { 0, 0 }
 };
 
@@ -1600,25 +1670,30 @@ init_gcc_specs (struct obstack *obstack, const char *shared_name,
 {
   char *buf;
 
 {
   char *buf;
 
-  buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
-               "}%{!static:%{!static-libgcc:",
+  buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
+               "%{!static:%{!static-libgcc:"
 #if USE_LD_AS_NEEDED
 #if USE_LD_AS_NEEDED
-               "%{!shared-libgcc:", static_name,
-               " --as-needed ", shared_name, " --no-as-needed}"
-               "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
-               "}",
+               "%{!shared-libgcc:",
+               static_name, " --as-needed ", shared_name, " --no-as-needed"
+               "}"
+               "%{shared-libgcc:",
+               shared_name, "%{!shared: ", static_name, "}"
+               "}"
 #else
 #else
-               "%{!shared:%{!shared-libgcc:", static_name, " ",
-               eh_name, "}%{shared-libgcc:", shared_name, " ",
-               static_name, "}}%{shared:",
+               "%{!shared:"
+               "%{!shared-libgcc:", static_name, " ", eh_name, "}"
+               "%{shared-libgcc:", shared_name, " ", static_name, "}"
+               "}"
 #ifdef LINK_EH_SPEC
 #ifdef LINK_EH_SPEC
-               "%{shared-libgcc:", shared_name,
-               "}%{!shared-libgcc:", static_name, "}",
+               "%{shared:"
+               "%{shared-libgcc:", shared_name, "}"
+               "%{!shared-libgcc:", static_name, "}"
+               "}"
 #else
 #else
-               shared_name,
+               "%{shared:", shared_name, "}"
 #endif
 #endif
 #endif
 #endif
-               "}}}", NULL);
+               "}}", NULL);
 
   obstack_grow (obstack, buf, strlen (buf));
   free (buf);
 
   obstack_grow (obstack, buf, strlen (buf));
   free (buf);
@@ -1641,8 +1716,7 @@ init_spec (void)
     notice ("Using built-in specs.\n");
 
 #ifdef EXTRA_SPECS
     notice ("Using built-in specs.\n");
 
 #ifdef EXTRA_SPECS
-  extra_specs = xcalloc (sizeof (struct spec_list),
-                        ARRAY_SIZE (extra_specs_1));
+  extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
 
   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
     {
 
   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
     {
@@ -1656,10 +1730,6 @@ init_spec (void)
     }
 #endif
 
     }
 #endif
 
-  /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
-     on ?: in file-scope variable initializations.  */
-  asm_debug = ASM_DEBUG_SPEC;
-
   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
     {
       sl = &static_specs[i];
   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
     {
       sl = &static_specs[i];
@@ -1804,7 +1874,7 @@ set_spec (const char *name, const char *spec)
   if (!sl)
     {
       /* Not found - make it.  */
   if (!sl)
     {
       /* Not found - make it.  */
-      sl = xmalloc (sizeof (struct spec_list));
+      sl = XNEW (struct spec_list);
       sl->name = xstrdup (name);
       sl->name_len = name_len;
       sl->ptr_spec = &sl->ptr;
       sl->name = xstrdup (name);
       sl->name_len = name_len;
       sl->ptr_spec = &sl->ptr;
@@ -1826,7 +1896,7 @@ set_spec (const char *name, const char *spec)
 
   /* Free the old spec.  */
   if (old_spec && sl->alloc_p)
 
   /* Free the old spec.  */
   if (old_spec && sl->alloc_p)
-    free ((void *) old_spec);
+    free (CONST_CAST(char *, old_spec));
 
   sl->alloc_p = 1;
 }
 
   sl->alloc_p = 1;
 }
@@ -1850,6 +1920,12 @@ static int argbuf_index;
 
 static int have_o_argbuf_index = 0;
 
 
 static int have_o_argbuf_index = 0;
 
+/* Were the options -c or -S passed.  */
+static int have_c = 0;
+
+/* Was the option -o passed.  */
+static int have_o = 0;
+
 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
    it here.  */
 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
    it here.  */
@@ -1881,7 +1957,7 @@ static void
 alloc_args (void)
 {
   argbuf_length = 10;
 alloc_args (void)
 {
   argbuf_length = 10;
-  argbuf = xmalloc (argbuf_length * sizeof (const char *));
+  argbuf = XNEWVEC (const char *, argbuf_length);
 }
 
 /* Clear out the vector of arguments (after a command is executed).  */
 }
 
 /* Clear out the vector of arguments (after a command is executed).  */
@@ -1903,7 +1979,7 @@ static void
 store_arg (const char *arg, int delete_always, int delete_failure)
 {
   if (argbuf_index + 1 == argbuf_length)
 store_arg (const char *arg, int delete_always, int delete_failure)
 {
   if (argbuf_index + 1 == argbuf_length)
-    argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
+    argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
 
   argbuf[argbuf_index++] = arg;
   argbuf[argbuf_index] = 0;
 
   argbuf[argbuf_index++] = arg;
   argbuf[argbuf_index] = 0;
@@ -1940,14 +2016,14 @@ load_specs (const char *filename)
     pfatal_with_name (filename);
 
   /* Read contents of file into BUFFER.  */
     pfatal_with_name (filename);
 
   /* Read contents of file into BUFFER.  */
-  buffer = xmalloc ((unsigned) statbuf.st_size + 1);
+  buffer = XNEWVEC (char, statbuf.st_size + 1);
   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
   if (readlen < 0)
     pfatal_with_name (filename);
   buffer[readlen] = 0;
   close (desc);
 
   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
   if (readlen < 0)
     pfatal_with_name (filename);
   buffer[readlen] = 0;
   close (desc);
 
-  specs = xmalloc (readlen + 1);
+  specs = XNEWVEC (char, readlen + 1);
   specs_p = specs;
   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
     {
   specs_p = specs;
   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
     {
@@ -2030,7 +2106,7 @@ read_specs (const char *filename, int main_p)
                       (long) (p1 - buffer + 1));
 
              p[-2] = '\0';
                       (long) (p1 - buffer + 1));
 
              p[-2] = '\0';
-             new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
+             new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
              read_specs (new_filename ? new_filename : p1, FALSE);
              continue;
            }
              read_specs (new_filename ? new_filename : p1, FALSE);
              continue;
            }
@@ -2049,7 +2125,7 @@ read_specs (const char *filename, int main_p)
                       (long) (p1 - buffer + 1));
 
              p[-2] = '\0';
                       (long) (p1 - buffer + 1));
 
              p[-2] = '\0';
-             new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
+             new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
              if (new_filename)
                read_specs (new_filename, FALSE);
              else if (verbose_flag)
              if (new_filename)
                read_specs (new_filename, FALSE);
              else if (verbose_flag)
@@ -2125,7 +2201,7 @@ read_specs (const char *filename, int main_p)
 
              set_spec (p2, *(sl->ptr_spec));
              if (sl->alloc_p)
 
              set_spec (p2, *(sl->ptr_spec));
              if (sl->alloc_p)
-               free ((void *) *(sl->ptr_spec));
+               free (CONST_CAST (char *, *(sl->ptr_spec)));
 
              *(sl->ptr_spec) = "";
              sl->alloc_p = 0;
 
              *(sl->ptr_spec) = "";
              sl->alloc_p = 0;
@@ -2195,8 +2271,7 @@ read_specs (const char *filename, int main_p)
        {
          /* Add this pair to the vector.  */
          compilers
        {
          /* Add this pair to the vector.  */
          compilers
-           = xrealloc (compilers,
-                       (n_compilers + 2) * sizeof (struct compiler));
+           = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
 
          compilers[n_compilers].suffix = suffix;
          compilers[n_compilers].spec = spec;
 
          compilers[n_compilers].suffix = suffix;
          compilers[n_compilers].spec = spec;
@@ -2263,7 +2338,7 @@ record_temp_file (const char *filename, int always_delete, int fail_delete)
        if (! strcmp (name, temp->name))
          goto already1;
 
        if (! strcmp (name, temp->name))
          goto already1;
 
-      temp = xmalloc (sizeof (struct temp_file));
+      temp = XNEW (struct temp_file);
       temp->next = always_delete_queue;
       temp->name = name;
       always_delete_queue = temp;
       temp->next = always_delete_queue;
       temp->name = name;
       always_delete_queue = temp;
@@ -2278,7 +2353,7 @@ record_temp_file (const char *filename, int always_delete, int fail_delete)
        if (! strcmp (name, temp->name))
          goto already2;
 
        if (! strcmp (name, temp->name))
          goto already2;
 
-      temp = xmalloc (sizeof (struct temp_file));
+      temp = XNEW (struct temp_file);
       temp->next = failure_delete_queue;
       temp->name = name;
       failure_delete_queue = temp;
       temp->next = failure_delete_queue;
       temp->name = name;
       failure_delete_queue = temp;
@@ -2346,65 +2421,224 @@ clear_failure_queue (void)
   failure_delete_queue = 0;
 }
 \f
   failure_delete_queue = 0;
 }
 \f
-/* Build a list of search directories from PATHS.
-   PREFIX is a string to prepend to the list.
-   If CHECK_DIR_P is nonzero we ensure the directory exists.
-   This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
-   It is also used by the --print-search-dirs flag.  */
-
-static char *
-build_search_list (struct path_prefix *paths, const char *prefix,
-                  int check_dir_p)
+/* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
+   returns non-NULL.
+   If DO_MULTI is true iterate over the paths twice, first with multilib
+   suffix then without, otherwise iterate over the paths once without
+   adding a multilib suffix.  When DO_MULTI is true, some attempt is made
+   to avoid visiting the same path twice, but we could do better.  For
+   instance, /usr/lib/../lib is considered different from /usr/lib.
+   At least EXTRA_SPACE chars past the end of the path passed to
+   CALLBACK are available for use by the callback.
+   CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
+
+   Returns the value returned by CALLBACK.  */
+
+static void *
+for_each_path (const struct path_prefix *paths,
+              bool do_multi,
+              size_t extra_space,
+              void *(*callback) (char *, void *),
+              void *callback_info)
 {
 {
-  int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
-  int just_suffix_len
-    = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
-  int first_time = TRUE;
-  struct prefix_list *pprefix;
-
-  obstack_grow (&collect_obstack, prefix, strlen (prefix));
-  obstack_1grow (&collect_obstack, '=');
-
-  for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
+  struct prefix_list *pl;
+  const char *multi_dir = NULL;
+  const char *multi_os_dir = NULL;
+  const char *multi_suffix;
+  const char *just_multi_suffix;
+  char *path = NULL;
+  void *ret = NULL;
+  bool skip_multi_dir = false;
+  bool skip_multi_os_dir = false;
+
+  multi_suffix = machine_suffix;
+  just_multi_suffix = just_machine_suffix;
+  if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
     {
     {
-      int len = strlen (pprefix->prefix);
+      multi_dir = concat (multilib_dir, dir_separator_str, NULL);
+      multi_suffix = concat (multi_suffix, multi_dir, NULL);
+      just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
+    }
+  if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
+    multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
 
 
-      if (machine_suffix
-         && (! check_dir_p
-             || is_directory (pprefix->prefix, machine_suffix, 0)))
+  while (1)
+    {
+      size_t multi_dir_len = 0;
+      size_t multi_os_dir_len = 0;
+      size_t suffix_len;
+      size_t just_suffix_len;
+      size_t len;
+
+      if (multi_dir)
+       multi_dir_len = strlen (multi_dir);
+      if (multi_os_dir)
+       multi_os_dir_len = strlen (multi_os_dir);
+      suffix_len = strlen (multi_suffix);
+      just_suffix_len = strlen (just_multi_suffix);
+
+      if (path == NULL)
        {
        {
-         if (!first_time)
-           obstack_1grow (&collect_obstack, PATH_SEPARATOR);
-
-         first_time = FALSE;
-         obstack_grow (&collect_obstack, pprefix->prefix, len);
-         obstack_grow (&collect_obstack, machine_suffix, suffix_len);
+         len = paths->max_len + extra_space + 1;
+         if (suffix_len > multi_os_dir_len)
+           len += suffix_len;
+         else
+           len += multi_os_dir_len;
+         path = XNEWVEC (char, len);
        }
 
        }
 
-      if (just_machine_suffix
-         && pprefix->require_machine_suffix == 2
-         && (! check_dir_p
-             || is_directory (pprefix->prefix, just_machine_suffix, 0)))
+      for (pl = paths->plist; pl != 0; pl = pl->next)
        {
        {
-         if (! first_time)
-           obstack_1grow (&collect_obstack, PATH_SEPARATOR);
+         len = strlen (pl->prefix);
+         memcpy (path, pl->prefix, len);
+
+         /* Look first in MACHINE/VERSION subdirectory.  */
+         if (!skip_multi_dir)
+           {
+             memcpy (path + len, multi_suffix, suffix_len + 1);
+             ret = callback (path, callback_info);
+             if (ret)
+               break;
+           }
+
+         /* Some paths are tried with just the machine (ie. target)
+            subdir.  This is used for finding as, ld, etc.  */
+         if (!skip_multi_dir
+             && pl->require_machine_suffix == 2)
+           {
+             memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
+             ret = callback (path, callback_info);
+             if (ret)
+               break;
+           }
+
+         /* Now try the base path.  */
+         if (!pl->require_machine_suffix
+             && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
+           {
+             const char *this_multi;
+             size_t this_multi_len;
 
 
-         first_time = FALSE;
-         obstack_grow (&collect_obstack, pprefix->prefix, len);
-         obstack_grow (&collect_obstack, just_machine_suffix,
-                       just_suffix_len);
+             if (pl->os_multilib)
+               {
+                 this_multi = multi_os_dir;
+                 this_multi_len = multi_os_dir_len;
+               }
+             else
+               {
+                 this_multi = multi_dir;
+                 this_multi_len = multi_dir_len;
+               }
+
+             if (this_multi_len)
+               memcpy (path + len, this_multi, this_multi_len + 1);
+             else
+               path[len] = '\0';
+
+             ret = callback (path, callback_info);
+             if (ret)
+               break;
+           }
        }
        }
+      if (pl)
+       break;
 
 
-      if (! pprefix->require_machine_suffix)
-       {
-         if (! first_time)
-           obstack_1grow (&collect_obstack, PATH_SEPARATOR);
+      if (multi_dir == NULL && multi_os_dir == NULL)
+       break;
 
 
-         first_time = FALSE;
-         obstack_grow (&collect_obstack, pprefix->prefix, len);
+      /* Run through the paths again, this time without multilibs.
+        Don't repeat any we have already seen.  */
+      if (multi_dir)
+       {
+         free (CONST_CAST (char *, multi_dir));
+         multi_dir = NULL;
+         free (CONST_CAST (char *, multi_suffix));
+         multi_suffix = machine_suffix;
+         free (CONST_CAST (char *, just_multi_suffix));
+         just_multi_suffix = just_machine_suffix;
        }
        }
+      else
+       skip_multi_dir = true;
+      if (multi_os_dir)
+       {
+         free (CONST_CAST (char *, multi_os_dir));
+         multi_os_dir = NULL;
+       }
+      else
+       skip_multi_os_dir = true;
     }
 
     }
 
+  if (multi_dir)
+    {
+      free (CONST_CAST (char *, multi_dir));
+      free (CONST_CAST (char *, multi_suffix));
+      free (CONST_CAST (char *, just_multi_suffix));
+    }
+  if (multi_os_dir)
+    free (CONST_CAST (char *, multi_os_dir));
+  if (ret != path)
+    free (path);
+  return ret;
+}
+
+/* Callback for build_search_list.  Adds path to obstack being built.  */
+
+struct add_to_obstack_info {
+  struct obstack *ob;
+  bool check_dir;
+  bool first_time;
+};
+
+static void *
+add_to_obstack (char *path, void *data)
+{
+  struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
+
+  if (info->check_dir && !is_directory (path, false))
+    return NULL;
+
+  if (!info->first_time)
+    obstack_1grow (info->ob, PATH_SEPARATOR);
+
+  obstack_grow (info->ob, path, strlen (path));
+
+  info->first_time = false;
+  return NULL;
+}
+
+/* Add or change the value of an environment variable, outputting the
+   change to standard error if in verbose mode.  */
+static void
+xputenv (const char *string)
+{
+  if (verbose_flag)
+    notice ("%s\n", string);
+  putenv (CONST_CAST (char *, string));
+}
+
+/* Build a list of search directories from PATHS.
+   PREFIX is a string to prepend to the list.
+   If CHECK_DIR_P is true we ensure the directory exists.
+   If DO_MULTI is true, multilib paths are output first, then
+   non-multilib paths.
+   This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
+   It is also used by the --print-search-dirs flag.  */
+
+static char *
+build_search_list (const struct path_prefix *paths, const char *prefix,
+                  bool check_dir, bool do_multi)
+{
+  struct add_to_obstack_info info;
+
+  info.ob = &collect_obstack;
+  info.check_dir = check_dir;
+  info.first_time = true;
+
+  obstack_grow (&collect_obstack, prefix, strlen (prefix));
+  obstack_1grow (&collect_obstack, '=');
+
+  for_each_path (paths, do_multi, 0, add_to_obstack, &info);
+
   obstack_1grow (&collect_obstack, '\0');
   return XOBFINISH (&collect_obstack, char *);
 }
   obstack_1grow (&collect_obstack, '\0');
   return XOBFINISH (&collect_obstack, char *);
 }
@@ -2413,9 +2647,10 @@ build_search_list (struct path_prefix *paths, const char *prefix,
    for collect.  */
 
 static void
    for collect.  */
 
 static void
-putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
+putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
+                     bool do_multi)
 {
 {
-  putenv (build_search_list (paths, env_var, 1));
+  xputenv (build_search_list (paths, env_var, true, do_multi));
 }
 \f
 /* Check whether NAME can be accessed in MODE.  This is like access,
 }
 \f
 /* Check whether NAME can be accessed in MODE.  This is like access,
@@ -2436,20 +2671,53 @@ access_check (const char *name, int mode)
   return access (name, mode);
 }
 
   return access (name, mode);
 }
 
+/* Callback for find_a_file.  Appends the file name to the directory
+   path.  If the resulting file exists in the right mode, return the
+   full pathname to the file.  */
+
+struct file_at_path_info {
+  const char *name;
+  const char *suffix;
+  int name_len;
+  int suffix_len;
+  int mode;
+};
+
+static void *
+file_at_path (char *path, void *data)
+{
+  struct file_at_path_info *info = (struct file_at_path_info *) data;
+  size_t len = strlen (path);
+
+  memcpy (path + len, info->name, info->name_len);
+  len += info->name_len;
+
+  /* Some systems have a suffix for executable files.
+     So try appending that first.  */
+  if (info->suffix_len)
+    {
+      memcpy (path + len, info->suffix, info->suffix_len + 1);
+      if (access_check (path, info->mode) == 0)
+       return path;
+    }
+
+  path[len] = '\0';
+  if (access_check (path, info->mode) == 0)
+    return path;
+
+  return NULL;
+}
+
 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
-   access to check permissions.
+   access to check permissions.  If DO_MULTI is true, search multilib
+   paths then non-multilib paths, otherwise do not search multilib paths.
    Return 0 if not found, otherwise return its name, allocated with malloc.  */
 
 static char *
    Return 0 if not found, otherwise return its name, allocated with malloc.  */
 
 static char *
-find_a_file (struct path_prefix *pprefix, const char *name, int mode,
-            int multilib)
+find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
+            bool do_multi)
 {
 {
-  char *temp;
-  const char *const file_suffix =
-    ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
-  struct prefix_list *pl;
-  int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
-  const char *multilib_name, *multilib_os_name;
+  struct file_at_path_info info;
 
 #ifdef DEFAULT_ASSEMBLER
   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
 
 #ifdef DEFAULT_ASSEMBLER
   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
@@ -2461,112 +2729,25 @@ find_a_file (struct path_prefix *pprefix, const char *name, int mode,
     return xstrdup (DEFAULT_LINKER);
 #endif
 
     return xstrdup (DEFAULT_LINKER);
 #endif
 
-  if (machine_suffix)
-    len += strlen (machine_suffix);
-
-  multilib_name = name;
-  multilib_os_name = name;
-  if (multilib && multilib_os_dir)
-    {
-      int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
-      int len2 = strlen (multilib_os_dir) + 1;
-
-      len += len1 > len2 ? len1 : len2;
-      if (multilib_dir)
-       multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
-                                 NULL));
-      if (strcmp (multilib_os_dir, ".") != 0)
-       multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
-                                   NULL));
-    }
-
-  temp = xmalloc (len);
-
   /* Determine the filename to execute (special case for absolute paths).  */
 
   if (IS_ABSOLUTE_PATH (name))
     {
       if (access (name, mode) == 0)
   /* Determine the filename to execute (special case for absolute paths).  */
 
   if (IS_ABSOLUTE_PATH (name))
     {
       if (access (name, mode) == 0)
-       {
-         strcpy (temp, name);
-         return temp;
-       }
-    }
-  else
-    for (pl = pprefix->plist; pl; pl = pl->next)
-      {
-       const char *this_name
-         = pl->os_multilib ? multilib_os_name : multilib_name;
-
-       if (machine_suffix)
-         {
-           /* Some systems have a suffix for executable files.
-              So try appending that first.  */
-           if (file_suffix[0] != 0)
-             {
-               strcpy (temp, pl->prefix);
-               strcat (temp, machine_suffix);
-               strcat (temp, multilib_name);
-               strcat (temp, file_suffix);
-               if (access_check (temp, mode) == 0)
-                 return temp;
-             }
-
-           /* Now try just the multilib_name.  */
-           strcpy (temp, pl->prefix);
-           strcat (temp, machine_suffix);
-           strcat (temp, multilib_name);
-           if (access_check (temp, mode) == 0)
-             return temp;
-         }
-
-       /* Certain prefixes are tried with just the machine type,
-          not the version.  This is used for finding as, ld, etc.  */
-       if (just_machine_suffix && pl->require_machine_suffix == 2)
-         {
-           /* Some systems have a suffix for executable files.
-              So try appending that first.  */
-           if (file_suffix[0] != 0)
-             {
-               strcpy (temp, pl->prefix);
-               strcat (temp, just_machine_suffix);
-               strcat (temp, multilib_name);
-               strcat (temp, file_suffix);
-               if (access_check (temp, mode) == 0)
-                 return temp;
-             }
+       return xstrdup (name);
 
 
-           strcpy (temp, pl->prefix);
-           strcat (temp, just_machine_suffix);
-           strcat (temp, multilib_name);
-           if (access_check (temp, mode) == 0)
-             return temp;
-         }
-
-       /* Certain prefixes can't be used without the machine suffix
-          when the machine or version is explicitly specified.  */
-       if (! pl->require_machine_suffix)
-         {
-           /* Some systems have a suffix for executable files.
-              So try appending that first.  */
-           if (file_suffix[0] != 0)
-             {
-               strcpy (temp, pl->prefix);
-               strcat (temp, this_name);
-               strcat (temp, file_suffix);
-               if (access_check (temp, mode) == 0)
-                 return temp;
-             }
+      return NULL;
+    }
 
 
-           strcpy (temp, pl->prefix);
-           strcat (temp, this_name);
-           if (access_check (temp, mode) == 0)
-             return temp;
-         }
-      }
+  info.name = name;
+  info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
+  info.name_len = strlen (info.name);
+  info.suffix_len = strlen (info.suffix);
+  info.mode = mode;
 
 
-  free (temp);
-  return 0;
+  return (char*) for_each_path (pprefix, do_multi,
+                               info.name_len + info.suffix_len,
+                               file_at_path, &info);
 }
 
 /* Ranking of prefixes in the sort list. -B prefixes are put before
 }
 
 /* Ranking of prefixes in the sort list. -B prefixes are put before
@@ -2612,7 +2793,7 @@ add_prefix (struct path_prefix *pprefix, const char *prefix,
   if (len > pprefix->max_len)
     pprefix->max_len = len;
 
   if (len > pprefix->max_len)
     pprefix->max_len = len;
 
-  pl = xmalloc (sizeof (struct prefix_list));
+  pl = XNEW (struct prefix_list);
   pl->prefix = prefix;
   pl->require_machine_suffix = require_machine_suffix;
   pl->priority = priority;
   pl->prefix = prefix;
   pl->require_machine_suffix = require_machine_suffix;
   pl->priority = priority;
@@ -2624,6 +2805,7 @@ add_prefix (struct path_prefix *pprefix, const char *prefix,
 }
 
 /* Same as add_prefix, but prepending target_system_root to prefix.  */
 }
 
 /* Same as add_prefix, but prepending target_system_root to prefix.  */
+/* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
 static void
 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
                      const char *component,
 static void
 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
                      const char *component,
@@ -2671,13 +2853,20 @@ execute (void)
 
   gcc_assert (!processing_spec_function);
 
 
   gcc_assert (!processing_spec_function);
 
+  if (wrapper_string)
+    {
+      string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
+      argbuf[0] = (string) ? string : argbuf[0];
+      insert_wrapper (wrapper_string);
+    }
+
   /* Count # of piped commands.  */
   for (n_commands = 1, i = 0; i < argbuf_index; i++)
     if (strcmp (argbuf[i], "|") == 0)
       n_commands++;
 
   /* Get storage for each command.  */
   /* Count # of piped commands.  */
   for (n_commands = 1, i = 0; i < argbuf_index; i++)
     if (strcmp (argbuf[i], "|") == 0)
       n_commands++;
 
   /* Get storage for each command.  */
-  commands = alloca (n_commands * sizeof (struct command));
+  commands = (struct command *) alloca (n_commands * sizeof (struct command));
 
   /* Split argbuf into its separate piped processes,
      and record info about each one.
 
   /* Split argbuf into its separate piped processes,
      and record info about each one.
@@ -2685,10 +2874,12 @@ execute (void)
 
   commands[0].prog = argbuf[0]; /* first command.  */
   commands[0].argv = &argbuf[0];
 
   commands[0].prog = argbuf[0]; /* first command.  */
   commands[0].argv = &argbuf[0];
-  string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
-
-  if (string)
-    commands[0].argv[0] = string;
+  if (!wrapper_string)
+    {
+      string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
+      commands[0].argv[0] = (string) ? string : commands[0].argv[0];
+    }
 
   for (n_commands = 1, i = 0; i < argbuf_index; i++)
     if (strcmp (argbuf[i], "|") == 0)
 
   for (n_commands = 1, i = 0; i < argbuf_index; i++)
     if (strcmp (argbuf[i], "|") == 0)
@@ -2700,7 +2891,7 @@ execute (void)
        commands[n_commands].prog = argbuf[i + 1];
        commands[n_commands].argv = &argbuf[i + 1];
        string = find_a_file (&exec_prefixes, commands[n_commands].prog,
        commands[n_commands].prog = argbuf[i + 1];
        commands[n_commands].argv = &argbuf[i + 1];
        string = find_a_file (&exec_prefixes, commands[n_commands].prog,
-                             X_OK, 0);
+                             X_OK, false);
        if (string)
          commands[n_commands].argv[0] = string;
        n_commands++;
        if (string)
          commands[n_commands].argv[0] = string;
        n_commands++;
@@ -2782,7 +2973,7 @@ execute (void)
       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
        ;
 
       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
        ;
 
-      argv = alloca ((argc + 3) * sizeof (char *));
+      argv = XALLOCAVEC (const char *, argc + 3);
 
       argv[0] = VALGRIND_PATH;
       argv[1] = "-q";
 
       argv[0] = VALGRIND_PATH;
       argv[1] = "-q";
@@ -2811,7 +3002,7 @@ execute (void)
       errmsg = pex_run (pex,
                        ((i + 1 == n_commands ? PEX_LAST : 0)
                         | (string == commands[i].prog ? PEX_SEARCH : 0)),
       errmsg = pex_run (pex,
                        ((i + 1 == n_commands ? PEX_LAST : 0)
                         | (string == commands[i].prog ? PEX_SEARCH : 0)),
-                       string, (char * const *) commands[i].argv,
+                       string, CONST_CAST (char **, commands[i].argv),
                        NULL, NULL, &err);
       if (errmsg != NULL)
        {
                        NULL, NULL, &err);
       if (errmsg != NULL)
        {
@@ -2825,7 +3016,7 @@ execute (void)
        }
 
       if (string != commands[i].prog)
        }
 
       if (string != commands[i].prog)
-       free ((void *) string);
+       free (CONST_CAST (char *, string));
     }
 
   execution_count++;
     }
 
   execution_count++;
@@ -2837,13 +3028,13 @@ execute (void)
     struct pex_time *times = NULL;
     int ret_code = 0;
 
     struct pex_time *times = NULL;
     int ret_code = 0;
 
-    statuses = alloca (n_commands * sizeof (int));
+    statuses = (int *) alloca (n_commands * sizeof (int));
     if (!pex_get_status (pex, n_commands, statuses))
       pfatal_with_name (_("failed to get exit status"));
 
     if (report_times)
       {
     if (!pex_get_status (pex, n_commands, statuses))
       pfatal_with_name (_("failed to get exit status"));
 
     if (report_times)
       {
-       times = alloca (n_commands * sizeof (struct pex_time));
+       times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
        if (!pex_get_times (pex, n_commands, times))
          pfatal_with_name (_("failed to get process times"));
       }
        if (!pex_get_times (pex, n_commands, times))
          pfatal_with_name (_("failed to get process times"));
       }
@@ -2865,17 +3056,18 @@ execute (void)
               we would otherwise have succeeded.  */
            if (WTERMSIG (status) == SIGPIPE
                && (signal_count || greatest_status >= MIN_FATAL_STATUS))
               we would otherwise have succeeded.  */
            if (WTERMSIG (status) == SIGPIPE
                && (signal_count || greatest_status >= MIN_FATAL_STATUS))
-             ;
+             {
+               signal_count++;
+               ret_code = -1;
+             }
            else
 #endif
            else
 #endif
-             fatal ("\
+             fatal_ice ("\
 Internal error: %s (program %s)\n\
 Please submit a full bug report.\n\
 See %s for instructions.",
 Internal error: %s (program %s)\n\
 Please submit a full bug report.\n\
 See %s for instructions.",
-                    strsignal (WTERMSIG (status)), commands[i].prog,
-                    bug_report_url);
-           signal_count++;
-           ret_code = -1;
+                       strsignal (WTERMSIG (status)), commands[i].prog,
+                       bug_report_url);
          }
        else if (WIFEXITED (status)
                 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
          }
        else if (WIFEXITED (status)
                 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
@@ -2910,24 +3102,22 @@ See %s for instructions.",
    If a switch uses following arguments, then the `part1' field
    is the switch itself and the `args' field
    is a null-terminated vector containing the following arguments.
    If a switch uses following arguments, then the `part1' field
    is the switch itself and the `args' field
    is a null-terminated vector containing the following arguments.
-   The `live_cond' field is:
-   0 when initialized
-   1 if the switch is true in a conditional spec,
-   -1 if false (overridden by a later switch)
-   -2 if this switch should be ignored (used in %<S)
+   Bits in the `live_cond' field are:
+   SWITCH_LIVE to indicate this switch is true in a conditional spec.
+   SWITCH_FALSE to indicate this switch is overridden by a later switch.
+   SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
    The `validated' field is nonzero if any spec has looked at this switch;
    if it remains zero at the end of the run, it must be meaningless.  */
 
    The `validated' field is nonzero if any spec has looked at this switch;
    if it remains zero at the end of the run, it must be meaningless.  */
 
-#define SWITCH_OK       0
-#define SWITCH_FALSE   -1
-#define SWITCH_IGNORE  -2
-#define SWITCH_LIVE     1
+#define SWITCH_LIVE    0x1
+#define SWITCH_FALSE   0x2
+#define SWITCH_IGNORE  0x4
 
 struct switchstr
 {
   const char *part1;
   const char **args;
 
 struct switchstr
 {
   const char *part1;
   const char **args;
-  int live_cond;
+  unsigned int live_cond;
   unsigned char validated;
   unsigned char ordering;
 };
   unsigned char validated;
   unsigned char ordering;
 };
@@ -3038,6 +3228,8 @@ display_help (void)
   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
   fputs (_("  --help                   Display this information\n"), stdout);
   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
   fputs (_("  --help                   Display this information\n"), stdout);
   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
+  fputs (_("  --help={target|optimizers|warnings|undocumented|params}[,{[^]joined|[^]separate}]\n"), stdout);
+  fputs (_("                           Display specific types of command line options\n"), stdout);
   if (! verbose_flag)
     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
   if (! verbose_flag)
     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
@@ -3052,6 +3244,8 @@ display_help (void)
   -print-multi-lib         Display the mapping between command line options and\n\
                            multiple library search directories\n"), stdout);
   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
   -print-multi-lib         Display the mapping between command line options and\n\
                            multiple library search directories\n"), stdout);
   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
+  fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
+  fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
@@ -3064,6 +3258,9 @@ display_help (void)
   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
+  fputs (_("\
+  --sysroot=<directory>    Use <directory> as the root directory for headers\n\
+                           and libraries\n"), stdout);
   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
@@ -3096,10 +3293,10 @@ add_preprocessor_option (const char *option, int len)
   n_preprocessor_options++;
 
   if (! preprocessor_options)
   n_preprocessor_options++;
 
   if (! preprocessor_options)
-    preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
+    preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
   else
   else
-    preprocessor_options = xrealloc (preprocessor_options,
-                                    n_preprocessor_options * sizeof (char *));
+    preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
+                                      n_preprocessor_options);
 
   preprocessor_options [n_preprocessor_options - 1] =
     save_string (option, len);
 
   preprocessor_options [n_preprocessor_options - 1] =
     save_string (option, len);
@@ -3111,10 +3308,10 @@ add_assembler_option (const char *option, int len)
   n_assembler_options++;
 
   if (! assembler_options)
   n_assembler_options++;
 
   if (! assembler_options)
-    assembler_options = xmalloc (n_assembler_options * sizeof (char *));
+    assembler_options = XNEWVEC (char *, n_assembler_options);
   else
   else
-    assembler_options = xrealloc (assembler_options,
-                                 n_assembler_options * sizeof (char *));
+    assembler_options = XRESIZEVEC (char *, assembler_options,
+                                   n_assembler_options);
 
   assembler_options [n_assembler_options - 1] = save_string (option, len);
 }
 
   assembler_options [n_assembler_options - 1] = save_string (option, len);
 }
@@ -3125,10 +3322,9 @@ add_linker_option (const char *option, int len)
   n_linker_options++;
 
   if (! linker_options)
   n_linker_options++;
 
   if (! linker_options)
-    linker_options = xmalloc (n_linker_options * sizeof (char *));
+    linker_options = XNEWVEC (char *, n_linker_options);
   else
   else
-    linker_options = xrealloc (linker_options,
-                              n_linker_options * sizeof (char *));
+    linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);  
 
   linker_options [n_linker_options - 1] = save_string (option, len);
 }
 
   linker_options [n_linker_options - 1] = save_string (option, len);
 }
@@ -3144,12 +3340,12 @@ process_command (int argc, const char **argv)
   char *temp1;
   const char *spec_lang = 0;
   int last_language_n_infiles;
   char *temp1;
   const char *spec_lang = 0;
   int last_language_n_infiles;
-  int have_c = 0;
   int lang_n_infiles = 0;
 #ifdef MODIFY_TARGET_NAME
   int is_modify_target_name;
   int lang_n_infiles = 0;
 #ifdef MODIFY_TARGET_NAME
   int is_modify_target_name;
-  int j;
+  unsigned int j;
 #endif
 #endif
+  const char *tooldir_prefix;
 
   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
 
 
   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
 
@@ -3171,9 +3367,12 @@ process_command (int argc, const char **argv)
     }
 
   /* If there is a -V or -b option (or both), process it now, before
     }
 
   /* If there is a -V or -b option (or both), process it now, before
-     trying to interpret the rest of the command line.  */
+     trying to interpret the rest of the command line.
+     Use heuristic that all configuration names must have at least
+     one dash '-'. This allows us to pass options starting with -b.  */
   if (argc > 1 && argv[1][0] == '-'
   if (argc > 1 && argv[1][0] == '-'
-      && (argv[1][1] == 'V' || argv[1][1] == 'b'))
+      && (argv[1][1] == 'V' ||
+        ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
     {
       const char *new_version = DEFAULT_TARGET_VERSION;
       const char *new_machine = DEFAULT_TARGET_MACHINE;
     {
       const char *new_version = DEFAULT_TARGET_VERSION;
       const char *new_machine = DEFAULT_TARGET_MACHINE;
@@ -3183,7 +3382,8 @@ process_command (int argc, const char **argv)
       int baselen;
 
       while (argc > 1 && argv[1][0] == '-'
       int baselen;
 
       while (argc > 1 && argv[1][0] == '-'
-            && (argv[1][1] == 'V' || argv[1][1] == 'b'))
+            && (argv[1][1] == 'V' ||
+               ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
        {
          char opt = argv[1][1];
          const char *arg;
        {
          char opt = argv[1][1];
          const char *arg;
@@ -3210,15 +3410,14 @@ process_command (int argc, const char **argv)
       for (baselen = strlen (progname); baselen > 0; baselen--)
        if (IS_DIR_SEPARATOR (progname[baselen-1]))
          break;
       for (baselen = strlen (progname); baselen > 0; baselen--)
        if (IS_DIR_SEPARATOR (progname[baselen-1]))
          break;
-      new_argv0 = xmemdup (progname, baselen,
+      new_argv0 = XDUPVAR (char, progname, baselen,
                           baselen + concat_length (new_version, new_machine,
                                                    "-gcc-", NULL) + 1);
       strcpy (new_argv0 + baselen, new_machine);
       strcat (new_argv0, "-gcc-");
       strcat (new_argv0, new_version);
 
                           baselen + concat_length (new_version, new_machine,
                                                    "-gcc-", NULL) + 1);
       strcpy (new_argv0 + baselen, new_machine);
       strcat (new_argv0, "-gcc-");
       strcat (new_argv0, new_version);
 
-      new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
-                         (argc + 1) * sizeof (argv[0]));
+      new_argv = XDUPVEC (char *, argv, argc + 1);
       new_argv[0] = new_argv0;
 
       execvp (new_argv0, new_argv);
       new_argv[0] = new_argv0;
 
       execvp (new_argv0, new_argv);
@@ -3235,18 +3434,34 @@ process_command (int argc, const char **argv)
     {
       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
                                              standard_exec_prefix);
     {
       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
                                              standard_exec_prefix);
-      gcc_libexec_prefix = make_relative_prefix (argv[0], 
+      gcc_libexec_prefix = make_relative_prefix (argv[0],
                                                 standard_bindir_prefix,
                                                 standard_libexec_prefix);
       if (gcc_exec_prefix)
                                                 standard_bindir_prefix,
                                                 standard_libexec_prefix);
       if (gcc_exec_prefix)
-       putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
+       xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
     }
   else
     }
   else
-    gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
-                                              standard_exec_prefix,
-                                              standard_libexec_prefix);
+    {
+      /* make_relative_prefix requires a program name, but
+        GCC_EXEC_PREFIX is typically a directory name with a trailing
+        / (which is ignored by make_relative_prefix), so append a
+        program name.  */
+      char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
+      gcc_libexec_prefix = make_relative_prefix (tmp_prefix,
+                                                standard_exec_prefix,
+                                                standard_libexec_prefix);
+
+      /* The path is unrelocated, so fallback to the original setting.  */
+      if (!gcc_libexec_prefix)
+       gcc_libexec_prefix = standard_libexec_prefix;
+
+      free (tmp_prefix);
+    }
 #else
 #endif
 #else
 #endif
+  /* From this point onward, gcc_exec_prefix is non-null if the toolchain
+     is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
+     or an automatically created GCC_EXEC_PREFIX from argv[0].  */
 
   if (gcc_exec_prefix)
     {
 
   if (gcc_exec_prefix)
     {
@@ -3277,7 +3492,7 @@ process_command (int argc, const char **argv)
   if (temp)
     {
       const char *startp, *endp;
   if (temp)
     {
       const char *startp, *endp;
-      char *nstore = alloca (strlen (temp) + 3);
+      char *nstore = (char *) alloca (strlen (temp) + 3);
 
       startp = endp = temp;
       while (1)
 
       startp = endp = temp;
       while (1)
@@ -3311,7 +3526,7 @@ process_command (int argc, const char **argv)
   if (temp && *cross_compile == '0')
     {
       const char *startp, *endp;
   if (temp && *cross_compile == '0')
     {
       const char *startp, *endp;
-      char *nstore = alloca (strlen (temp) + 3);
+      char *nstore = (char *) alloca (strlen (temp) + 3);
 
       startp = endp = temp;
       while (1)
 
       startp = endp = temp;
       while (1)
@@ -3344,7 +3559,7 @@ process_command (int argc, const char **argv)
   if (temp && *cross_compile == '0')
     {
       const char *startp, *endp;
   if (temp && *cross_compile == '0')
     {
       const char *startp, *endp;
-      char *nstore = alloca (strlen (temp) + 3);
+      char *nstore = (char *) alloca (strlen (temp) + 3);
 
       startp = endp = temp;
       while (1)
 
       startp = endp = temp;
       while (1)
@@ -3407,8 +3622,9 @@ process_command (int argc, const char **argv)
       else if (strcmp (argv[i], "-fversion") == 0)
        {
          /* translate_options () has turned --version into -fversion.  */
       else if (strcmp (argv[i], "-fversion") == 0)
        {
          /* translate_options () has turned --version into -fversion.  */
-         printf (_("%s (GCC) %s\n"), programname, version_string);
-         printf ("Copyright %s 2005 Free Software Foundation, Inc.\n",
+         printf (_("%s %s%s\n"), programname, pkgversion_string,
+                 version_string);
+         printf ("Copyright %s 2008 Free Software Foundation, Inc.\n",
                  _("(C)"));
          fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
                  _("(C)"));
          fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
@@ -3430,10 +3646,19 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
          add_assembler_option ("--help", 6);
          add_linker_option ("--help", 6);
        }
          add_assembler_option ("--help", 6);
          add_linker_option ("--help", 6);
        }
+      else if (strncmp (argv[i], "-fhelp=", 7) == 0)
+       {
+         /* translate_options () has turned --help into -fhelp.  */
+         print_subprocess_help = 2;
+
+         /* We will be passing a dummy file on to the sub-processes.  */
+         n_infiles++;
+         n_switches++;
+       }
       else if (strcmp (argv[i], "-ftarget-help") == 0)
        {
          /* translate_options() has turned --target-help into -ftarget-help.  */
       else if (strcmp (argv[i], "-ftarget-help") == 0)
        {
          /* translate_options() has turned --target-help into -ftarget-help.  */
-         target_help_flag = 1;
+         print_subprocess_help = 1;
 
          /* We will be passing a dummy file on to the sub-processes.  */
          n_infiles++;
 
          /* We will be passing a dummy file on to the sub-processes.  */
          n_infiles++;
@@ -3462,8 +3687,12 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
        print_multi_lib = 1;
       else if (! strcmp (argv[i], "-print-multi-directory"))
        print_multi_directory = 1;
        print_multi_lib = 1;
       else if (! strcmp (argv[i], "-print-multi-directory"))
        print_multi_directory = 1;
+      else if (! strcmp (argv[i], "-print-sysroot"))
+       print_sysroot = 1;
       else if (! strcmp (argv[i], "-print-multi-os-directory"))
        print_multi_os_directory = 1;
       else if (! strcmp (argv[i], "-print-multi-os-directory"))
        print_multi_os_directory = 1;
+      else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
+       print_sysroot_headers_suffix = 1;
       else if (! strncmp (argv[i], "-Wa,", 4))
        {
          int prev, j;
       else if (! strncmp (argv[i], "-Wa,", 4))
        {
          int prev, j;
@@ -3552,7 +3781,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
        }
       else if (strcmp (argv[i], "-specs") == 0)
        {
        }
       else if (strcmp (argv[i], "-specs") == 0)
        {
-         struct user_specs *user = xmalloc (sizeof (struct user_specs));
+         struct user_specs *user = XNEW (struct user_specs);
          if (++i >= argc)
            fatal ("argument to '-specs' is missing");
 
          if (++i >= argc)
            fatal ("argument to '-specs' is missing");
 
@@ -3566,7 +3795,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
        }
       else if (strncmp (argv[i], "-specs=", 7) == 0)
        {
        }
       else if (strncmp (argv[i], "-specs=", 7) == 0)
        {
-         struct user_specs *user = xmalloc (sizeof (struct user_specs));
+         struct user_specs *user = XNEW (struct user_specs);
          if (strlen (argv[i]) == 7)
            fatal ("argument to '-specs=' is missing");
 
          if (strlen (argv[i]) == 7)
            fatal ("argument to '-specs=' is missing");
 
@@ -3587,6 +3816,15 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
          use_pipes = 1;
          n_switches++;
        }
          use_pipes = 1;
          n_switches++;
        }
+      else if (strcmp (argv[i], "-wrapper") == 0)
+        {
+         if (++i >= argc)
+           fatal ("argument to '-wrapper' is missing");
+
+          wrapper_string = argv[i];
+         n_switches++;
+         n_switches++;
+        }
       else if (strcmp (argv[i], "-###") == 0)
        {
          /* This is similar to -v except that there is no execution
       else if (strcmp (argv[i], "-###") == 0)
        {
          /* This is similar to -v except that there is no execution
@@ -3604,6 +3842,10 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
          switch (c)
            {
            case 'b':
          switch (c)
            {
            case 'b':
+             if (NULL == strchr(argv[i] + 2, '-'))
+               goto normal_switch;
+
+             /* Fall through.  */
            case 'V':
              fatal ("'-%c' must come at the start of the command line", c);
              break;
            case 'V':
              fatal ("'-%c' must come at the start of the command line", c);
              break;
@@ -3630,37 +3872,15 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
                   if appending a directory separator actually makes a
                   valid directory name.  */
                if (! IS_DIR_SEPARATOR (value [len - 1])
                   if appending a directory separator actually makes a
                   valid directory name.  */
                if (! IS_DIR_SEPARATOR (value [len - 1])
-                   && is_directory (value, "", 0))
+                   && is_directory (value, false))
                  {
                  {
-                   char *tmp = xmalloc (len + 2);
+                   char *tmp = XNEWVEC (char, len + 2);
                    strcpy (tmp, value);
                    tmp[len] = DIR_SEPARATOR;
                    tmp[++ len] = 0;
                    value = tmp;
                  }
 
                    strcpy (tmp, value);
                    tmp[len] = DIR_SEPARATOR;
                    tmp[++ len] = 0;
                    value = tmp;
                  }
 
-               /* As a kludge, if the arg is "[foo/]stageN/", just
-                  add "[foo/]include" to the include prefix.  */
-               if ((len == 7
-                    || (len > 7
-                        && (IS_DIR_SEPARATOR (value[len - 8]))))
-                   && strncmp (value + len - 7, "stage", 5) == 0
-                   && ISDIGIT (value[len - 2])
-                   && (IS_DIR_SEPARATOR (value[len - 1])))
-                 {
-                   if (len == 7)
-                     add_prefix (&include_prefixes, "./", NULL,
-                                 PREFIX_PRIORITY_B_OPT, 0, 0);
-                   else
-                     {
-                       char *string = xmalloc (len - 6);
-                       memcpy (string, value, len - 7);
-                       string[len - 7] = 0;
-                       add_prefix (&include_prefixes, string, NULL,
-                                   PREFIX_PRIORITY_B_OPT, 0, 0);
-                     }
-                 }
-
                add_prefix (&exec_prefixes, value, NULL,
                            PREFIX_PRIORITY_B_OPT, 0, 0);
                add_prefix (&startfile_prefixes, value, NULL,
                add_prefix (&exec_prefixes, value, NULL,
                            PREFIX_PRIORITY_B_OPT, 0, 0);
                add_prefix (&startfile_prefixes, value, NULL,
@@ -3691,6 +3911,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
              goto normal_switch;
 
            case 'o':
              goto normal_switch;
 
            case 'o':
+             have_o = 1;
 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
              if (! have_c)
                {
 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
              if (! have_c)
                {
@@ -3737,7 +3958,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
              for (j = 0; j < ARRAY_SIZE (modify_target); j++)
                if (! strcmp (argv[i], modify_target[j].sw))
                  {
              for (j = 0; j < ARRAY_SIZE (modify_target); j++)
                if (! strcmp (argv[i], modify_target[j].sw))
                  {
-                   char *new_name = xmalloc (strlen (modify_target[j].str)
+                   char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
                                              + strlen (spec_machine));
                    const char *p, *r;
                    char *q;
                                              + strlen (spec_machine));
                    const char *p, *r;
                    char *q;
@@ -3791,62 +4012,50 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
       use_pipes = 0;
     }
 
       use_pipes = 0;
     }
 
-  /* Set up the search paths before we go looking for config files.  */
+  /* Set up the search paths.  We add directories that we expect to
+     contain GNU Toolchain components before directories specified by
+     the machine description so that we will find GNU components (like
+     the GNU assembler) before those of the host system.  */ 
 
 
-  /* These come before the md prefixes so that we will find gcc's subcommands
-     (such as cpp) rather than those of the host system.  */
-  /* Use 2 as fourth arg meaning try just the machine as a suffix,
-     as well as trying the machine and the version.  */
+  /* If we don't know where the toolchain has been installed, use the
+     configured-in locations.  */
+  if (!gcc_exec_prefix)
+    {
 #ifndef OS2
 #ifndef OS2
-  add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
-             PREFIX_PRIORITY_LAST, 1, 0);
-  add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 2, 0);
-  add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 2, 0);
-  add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 2, 0);
-  add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 2, 0);
+      add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
+                 PREFIX_PRIORITY_LAST, 1, 0);
+      add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 2, 0);
+      add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 2, 0);
 #endif
 #endif
+      add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 1, 0);
+    }
 
 
-  add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 1, 0);
-  add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
-             PREFIX_PRIORITY_LAST, 1, 0);
+  /* If not cross-compiling, search well-known system locations.  */
+  if (*cross_compile == '0')
+    {
+#ifndef OS2
+      add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 2, 0);
+      add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 2, 0);
+#endif
+      add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
+                 PREFIX_PRIORITY_LAST, 1, 0);
+    }
 
 
+  gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
                           dir_separator_str, NULL);
 
   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
                           dir_separator_str, NULL);
 
-  /* If tooldir is relative, base it on exec_prefixes.  A relative
-     tooldir lets us move the installed tree as a unit.
-
-     If GCC_EXEC_PREFIX is defined, then we want to add two relative
-     directories, so that we can search both the user specified directory
-     and the standard place.  */
-
-  if (!IS_ABSOLUTE_PATH (tooldir_prefix))
-    {
-      if (gcc_exec_prefix)
-       {
-         char *gcc_exec_tooldir_prefix
-           = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
-                     spec_version, dir_separator_str, tooldir_prefix, NULL);
-
-         add_prefix (&exec_prefixes,
-                     concat (gcc_exec_tooldir_prefix, "bin",
-                             dir_separator_str, NULL),
-                     NULL, PREFIX_PRIORITY_LAST, 0, 0);
-         add_prefix (&startfile_prefixes,
-                     concat (gcc_exec_tooldir_prefix, "lib",
-                             dir_separator_str, NULL),
-                     NULL, PREFIX_PRIORITY_LAST, 0, 1);
-       }
-
-      tooldir_prefix = concat (standard_exec_prefix, spec_machine,
-                              dir_separator_str, spec_version,
-                              dir_separator_str, tooldir_prefix, NULL);
-    }
+  /* Look for tools relative to the location from which the driver is
+     running, or, if that is not available, the configured prefix.  */
+  tooldir_prefix
+    = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
+             spec_machine, dir_separator_str,
+             spec_version, dir_separator_str, tooldir_prefix, NULL);
 
   add_prefix (&exec_prefixes,
              concat (tooldir_prefix, "bin", dir_separator_str, NULL),
 
   add_prefix (&exec_prefixes,
              concat (tooldir_prefix, "bin", dir_separator_str, NULL),
@@ -3878,8 +4087,8 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
 
   /* Then create the space for the vectors and scan again.  */
 
 
   /* Then create the space for the vectors and scan again.  */
 
-  switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
-  infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
+  switches = XNEWVEC (struct switchstr, n_switches + 1);
+  infiles = XNEWVEC (struct infile, n_infiles + 1);
   n_switches = 0;
   n_infiles = 0;
   last_language_n_infiles = -1;
   n_switches = 0;
   n_infiles = 0;
   last_language_n_infiles = -1;
@@ -3920,12 +4129,17 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
        ;
       else if (! strcmp (argv[i], "-print-multi-directory"))
        ;
        ;
       else if (! strcmp (argv[i], "-print-multi-directory"))
        ;
-      else if (! strcmp (argv[i], "-print-multi-os-directory"))
+      else if (! strcmp (argv[i], "-print-sysroot"))
        ;
        ;
-      else if (! strcmp (argv[i], "-ftarget-help"))
+      else if (! strcmp (argv[i], "-print-multi-os-directory"))
        ;
        ;
-      else if (! strcmp (argv[i], "-fhelp"))
+      else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
        ;
        ;
+      else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
+       {
+         target_system_root = argv[i] + strlen ("--sysroot=");
+         target_system_root_changed = 1;
+       }
       else if (argv[i][0] == '+' && argv[i][1] == 'e')
        {
          /* Compensate for the +e options to the C++ front-end;
       else if (argv[i][0] == '+' && argv[i][1] == 'e')
        {
          /* Compensate for the +e options to the C++ front-end;
@@ -3935,7 +4149,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
             -e0 or -e1 down into the linker.  */
          switches[n_switches].part1 = &argv[i][0];
          switches[n_switches].args = 0;
             -e0 or -e1 down into the linker.  */
          switches[n_switches].part1 = &argv[i][0];
          switches[n_switches].args = 0;
-         switches[n_switches].live_cond = SWITCH_OK;
+         switches[n_switches].live_cond = 0;
          switches[n_switches].validated = 0;
          n_switches++;
        }
          switches[n_switches].validated = 0;
          n_switches++;
        }
@@ -3978,6 +4192,8 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
          infiles[n_infiles].language = "*";
          infiles[n_infiles++].name = argv[i];
        }
          infiles[n_infiles].language = "*";
          infiles[n_infiles++].name = argv[i];
        }
+      else if (strcmp (argv[i], "-wrapper") == 0)
+        i++;
       else if (strcmp (argv[i], "-specs") == 0)
        i++;
       else if (strncmp (argv[i], "-specs=", 7) == 0)
       else if (strcmp (argv[i], "-specs") == 0)
        i++;
       else if (strncmp (argv[i], "-specs=", 7) == 0)
@@ -4024,7 +4240,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
              if (i + n_args >= argc)
                fatal ("argument to '-%s' is missing", p);
              switches[n_switches].args
              if (i + n_args >= argc)
                fatal ("argument to '-%s' is missing", p);
              switches[n_switches].args
-               = xmalloc ((n_args + 1) * sizeof(const char *));
+               = XNEWVEC (const char *, n_args + 1);
              while (j < n_args)
                switches[n_switches].args[j++] = argv[++i];
              /* Null-terminate the vector.  */
              while (j < n_args)
                switches[n_switches].args[j++] = argv[++i];
              /* Null-terminate the vector.  */
@@ -4034,26 +4250,28 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
            {
              /* On some systems, ld cannot handle some options without
                 a space.  So split the option from its argument.  */
            {
              /* On some systems, ld cannot handle some options without
                 a space.  So split the option from its argument.  */
-             char *part1 = xmalloc (2);
+             char *part1 = XNEWVEC (char, 2);
              part1[0] = c;
              part1[1] = '\0';
 
              switches[n_switches].part1 = part1;
              part1[0] = c;
              part1[1] = '\0';
 
              switches[n_switches].part1 = part1;
-             switches[n_switches].args = xmalloc (2 * sizeof (const char *));
+             switches[n_switches].args = XNEWVEC (const char *, 2);
              switches[n_switches].args[0] = xstrdup (p+1);
              switches[n_switches].args[1] = 0;
            }
          else
            switches[n_switches].args = 0;
 
              switches[n_switches].args[0] = xstrdup (p+1);
              switches[n_switches].args[1] = 0;
            }
          else
            switches[n_switches].args = 0;
 
-         switches[n_switches].live_cond = SWITCH_OK;
+         switches[n_switches].live_cond = 0;
          switches[n_switches].validated = 0;
          switches[n_switches].ordering = 0;
          switches[n_switches].validated = 0;
          switches[n_switches].ordering = 0;
-         /* These are always valid, since gcc.c itself understands them.  */
+         /* These are always valid, since gcc.c itself understands the
+            first four and gfortranspec.c understands -static-libgfortran.  */
          if (!strcmp (p, "save-temps")
              || !strcmp (p, "static-libgcc")
              || !strcmp (p, "shared-libgcc")
          if (!strcmp (p, "save-temps")
              || !strcmp (p, "static-libgcc")
              || !strcmp (p, "shared-libgcc")
-             || !strcmp (p, "pipe"))
+             || !strcmp (p, "pipe")
+             || !strcmp (p, "static-libgfortran"))
            switches[n_switches].validated = 1;
          else
            {
            switches[n_switches].validated = 1;
          else
            {
@@ -4086,34 +4304,14 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
     error ("warning: '-x %s' after last input file has no effect", spec_lang);
 
   /* Ensure we only invoke each subprocess once.  */
     error ("warning: '-x %s' after last input file has no effect", spec_lang);
 
   /* Ensure we only invoke each subprocess once.  */
-  if (target_help_flag || print_help_list)
+  if (print_subprocess_help || print_help_list)
     {
       n_infiles = 1;
 
     {
       n_infiles = 1;
 
-      /* Create a dummy input file, so that we can pass --target-help on to
-        the various sub-processes.  */
+      /* Create a dummy input file, so that we can pass
+        the help option on to the various sub-processes.  */
       infiles[0].language = "c";
       infiles[0].name   = "help-dummy";
       infiles[0].language = "c";
       infiles[0].name   = "help-dummy";
-
-      if (target_help_flag)
-       {
-         switches[n_switches].part1     = "--target-help";
-         switches[n_switches].args      = 0;
-         switches[n_switches].live_cond = SWITCH_OK;
-         switches[n_switches].validated = 0;
-
-         n_switches++;
-       }
-
-      if (print_help_list)
-       {
-         switches[n_switches].part1     = "--help";
-         switches[n_switches].args      = 0;
-         switches[n_switches].live_cond = SWITCH_OK;
-         switches[n_switches].validated = 0;
-
-         n_switches++;
-       }
     }
 
   switches[n_switches].part1 = 0;
     }
 
   switches[n_switches].part1 = 0;
@@ -4145,7 +4343,7 @@ set_collect_gcc_options (void)
       first_time = FALSE;
 
       /* Ignore elided switches.  */
       first_time = FALSE;
 
       /* Ignore elided switches.  */
-      if (switches[i].live_cond == SWITCH_IGNORE)
+      if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
        continue;
 
       obstack_grow (&collect_obstack, "'-", 2);
        continue;
 
       obstack_grow (&collect_obstack, "'-", 2);
@@ -4174,7 +4372,7 @@ set_collect_gcc_options (void)
        }
     }
   obstack_grow (&collect_obstack, "\0", 1);
        }
     }
   obstack_grow (&collect_obstack, "\0", 1);
-  putenv (XOBFINISH (&collect_obstack, char *));
+  xputenv (XOBFINISH (&collect_obstack, char *));
 }
 \f
 /* Process a spec string, accumulating and running commands.  */
 }
 \f
 /* Process a spec string, accumulating and running commands.  */
@@ -4227,6 +4425,72 @@ static int input_from_pipe;
    arguments.  */
 static const char *suffix_subst;
 
    arguments.  */
 static const char *suffix_subst;
 
+/* If there is an argument being accumulated, terminate it and store it.  */
+
+static void
+end_going_arg (void)
+{
+  if (arg_going)
+    {
+      const char *string;
+
+      obstack_1grow (&obstack, 0);
+      string = XOBFINISH (&obstack, const char *);
+      if (this_is_library_file)
+       string = find_file (string);
+      store_arg (string, delete_this_arg, this_is_output_file);
+      if (this_is_output_file)
+       outfiles[input_file_number] = string;
+      arg_going = 0;
+    }
+}
+
+
+/* Parse the WRAPPER string which is a comma separated list of the command line
+   and insert them into the beginning of argbuf.  */
+
+static void
+insert_wrapper (const char *wrapper)
+{
+  int n = 0;
+  int i;
+  char *buf = xstrdup (wrapper);
+  char *p = buf;
+
+  do
+    {
+      n++;
+      while (*p == ',')
+        p++;
+    }
+  while ((p = strchr (p, ',')) != NULL);
+
+  if (argbuf_index + n >= argbuf_length)
+    {
+      argbuf_length = argbuf_length * 2;
+      while (argbuf_length < argbuf_index + n)
+       argbuf_length *= 2;
+      argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
+    }
+  for (i = argbuf_index - 1; i >= 0; i--)
+    argbuf[i + n] = argbuf[i];
+
+  i = 0;
+  p = buf;
+  do
+    {
+      while (*p == ',')
+        {
+          *p = 0;
+          p++;
+        }
+      argbuf[i++] = p;
+    }
+  while ((p = strchr (p, ',')) != NULL);
+  gcc_assert (i == n);
+  argbuf_index += n;
+}
+
 /* Process the spec SPEC and run the commands specified therein.
    Returns 0 if the spec is successfully processed; -1 if failed.  */
 
 /* Process the spec SPEC and run the commands specified therein.
    Returns 0 if the spec is successfully processed; -1 if failed.  */
 
@@ -4256,7 +4520,6 @@ do_spec (const char *spec)
 static int
 do_spec_2 (const char *spec)
 {
 static int
 do_spec_2 (const char *spec)
 {
-  const char *string;
   int result;
 
   clear_args ();
   int result;
 
   clear_args ();
@@ -4269,18 +4532,7 @@ do_spec_2 (const char *spec)
 
   result = do_spec_1 (spec, 0, NULL);
 
 
   result = do_spec_1 (spec, 0, NULL);
 
-  /* End any pending argument.  */
-  if (arg_going)
-    {
-      obstack_1grow (&obstack, 0);
-      string = XOBFINISH (&obstack, const char *);
-      if (this_is_library_file)
-       string = find_file (string);
-      store_arg (string, delete_this_arg, this_is_output_file);
-      if (this_is_output_file)
-       outfiles[input_file_number] = string;
-      arg_going = 0;
-    }
+  end_going_arg ();
 
   return result;
 }
 
   return result;
 }
@@ -4318,7 +4570,7 @@ do_option_spec (const char *name, const char *spec)
     }
 
   /* Replace each %(VALUE) by the specified value.  */
     }
 
   /* Replace each %(VALUE) by the specified value.  */
-  tmp_spec = alloca (strlen (spec) + 1
+  tmp_spec = (char *) alloca (strlen (spec) + 1
                     + value_count * (value_len - strlen ("%(VALUE)")));
   tmp_spec_p = tmp_spec;
   q = spec;
                     + value_count * (value_len - strlen ("%(VALUE)")));
   tmp_spec_p = tmp_spec;
   q = spec;
@@ -4350,8 +4602,7 @@ do_self_spec (const char *spec)
 
       first = n_switches;
       n_switches += argbuf_index;
 
       first = n_switches;
       n_switches += argbuf_index;
-      switches = xrealloc (switches,
-                          sizeof (struct switchstr) * (n_switches + 1));
+      switches = XRESIZEVEC (struct switchstr, switches, n_switches + 1);
 
       switches[n_switches] = switches[first];
       for (i = 0; i < argbuf_index; i++)
 
       switches[n_switches] = switches[first];
       for (i = 0; i < argbuf_index; i++)
@@ -4365,115 +4616,62 @@ do_self_spec (const char *spec)
          sw = &switches[i + first];
          sw->part1 = &argbuf[i][1];
          sw->args = 0;
          sw = &switches[i + first];
          sw->part1 = &argbuf[i][1];
          sw->args = 0;
-         sw->live_cond = SWITCH_OK;
+         sw->live_cond = 0;
          sw->validated = 0;
          sw->ordering = 0;
        }
     }
 }
 
          sw->validated = 0;
          sw->ordering = 0;
        }
     }
 }
 
-void
-do_spec_path (struct prefix_list *pl, const char *option,
-             int omit_if_relative, int separate_options,
-             int only_subdir,
-             const char *dir_for_machine_suffix,
-             const char *dir_for_no_suffix)
+/* Callback for processing %D and %I specs.  */
+
+struct spec_path_info {
+  const char *option;
+  const char *append;
+  size_t append_len;
+  bool omit_relative;
+  bool separate_options;
+};
+
+static void *
+spec_path (char *path, void *data)
 {
 {
-  static size_t bufsize = 0;
-  static char *buffer;
-  int idx;
-  bool multilib_p = false;
-
-  /* Used on systems which record the specified -L dirs
-     and use them to search for dynamic linking.  */
-  /* Relative directories always come from -B,
-     and it is better not to use them for searching
-     at run time.  In particular, stage1 loses.  */
-  if (omit_if_relative
-      && !IS_ABSOLUTE_PATH (pl->prefix))
-    return;
+  struct spec_path_info *info = (struct spec_path_info *) data;
+  size_t len = 0;
+  char save = 0;
 
 
-  /* Try subdirectory if there is one.  */
-  if (machine_suffix && dir_for_machine_suffix)
-    {
-      if (strlen (pl->prefix) + strlen (machine_suffix)
-         >= bufsize)
-       bufsize = (strlen (pl->prefix)
-                 + strlen (machine_suffix)) * 2 + 1;
-      buffer = xrealloc (buffer, bufsize);
-      strcpy (buffer, pl->prefix);
-      strcat (buffer, machine_suffix);
-      if (is_directory (buffer, dir_for_machine_suffix, 1))
-       {
-         multilib_p = true;
-         do_spec_1 (option, separate_options, NULL);
-         if (separate_options)
-           do_spec_1 (" ", 0, NULL);
-         do_spec_1 (buffer, 1, NULL);
-         do_spec_1 (dir_for_machine_suffix, 1, NULL);
-         /* Make this a separate argument.  */
-         do_spec_1 (" ", 0, NULL);
-       }
-    }
-  if (!pl->require_machine_suffix && dir_for_no_suffix)
+  if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
+    return NULL;
+
+  if (info->append_len != 0)
     {
     {
-      if (is_directory (pl->prefix, dir_for_no_suffix, 1))
-       {
-         multilib_p = true;
-         do_spec_1 (option, separate_options, NULL);
-         if (separate_options)
-           do_spec_1 (" ", 0, NULL);
-         do_spec_1 (pl->prefix, 1, NULL);
-         do_spec_1 (dir_for_no_suffix, 1, NULL);
-         /* Make this a separate argument.  */
-         do_spec_1 (" ", 0, NULL);
-       }
+      len = strlen (path);
+      memcpy (path + len, info->append, info->append_len + 1);
     }
 
     }
 
-  if (only_subdir || multilib_p)
-    return;
+  if (!is_directory (path, true))
+    return NULL;
 
 
-  if (machine_suffix)
-    {
-      if (is_directory (pl->prefix, machine_suffix, 1))
-       {
-         do_spec_1 (option, separate_options, NULL);
-         if (separate_options)
-           do_spec_1 (" ", 0, NULL);
-         do_spec_1 (pl->prefix, 1, NULL);
-         /* Remove slash from machine_suffix.  */
-         if (strlen (machine_suffix) >= bufsize)
-           bufsize = strlen (machine_suffix) * 2 + 1;
-         buffer = xrealloc (buffer, bufsize);
-         strcpy (buffer, machine_suffix);
-         idx = strlen (buffer);
-         if (IS_DIR_SEPARATOR (buffer[idx - 1]))
-           buffer[idx - 1] = 0;
-         do_spec_1 (buffer, 1, NULL);
-         /* Make this a separate argument.  */
-         do_spec_1 (" ", 0, NULL);
-       }
-    }
-  if (!pl->require_machine_suffix)
+  do_spec_1 (info->option, 1, NULL);
+  if (info->separate_options)
+    do_spec_1 (" ", 0, NULL);
+
+  if (info->append_len == 0)
     {
     {
-      if (is_directory (pl->prefix, "", 1))
-       {
-         do_spec_1 (option, separate_options, NULL);
-         if (separate_options)
-           do_spec_1 (" ", 0, NULL);
-         /* Remove slash from pl->prefix.  */
-         if (strlen (pl->prefix) >= bufsize)
-           bufsize = strlen (pl->prefix) * 2 + 1;
-         buffer = xrealloc (buffer, bufsize);
-         strcpy (buffer, pl->prefix);
-         idx = strlen (buffer);
-         if (IS_DIR_SEPARATOR (buffer[idx - 1]))
-           buffer[idx - 1] = 0;
-         do_spec_1 (buffer, 1, NULL);
-         /* Make this a separate argument.  */
-         do_spec_1 (" ", 0, NULL);
-       }
+      len = strlen (path);
+      save = path[len - 1];
+      if (IS_DIR_SEPARATOR (path[len - 1]))
+       path[len - 1] = '\0';
     }
     }
+
+  do_spec_1 (path, 1, NULL);
+  do_spec_1 (" ", 0, NULL);
+
+  /* Must not damage the original path.  */
+  if (info->append_len == 0)
+    path[len - 1] = save;
+
+  return NULL;
 }
 
 /* Process the sub-spec SPEC as a portion of a larger spec.
 }
 
 /* Process the sub-spec SPEC as a portion of a larger spec.
@@ -4494,7 +4692,6 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
   const char *p = spec;
   int c;
   int i;
   const char *p = spec;
   int c;
   int i;
-  const char *string;
   int value;
 
   while ((c = *p++))
   int value;
 
   while ((c = *p++))
@@ -4503,19 +4700,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
     switch (inswitch ? 'a' : c)
       {
       case '\n':
     switch (inswitch ? 'a' : c)
       {
       case '\n':
-       /* End of line: finish any pending argument,
-          then run the pending command if one has been started.  */
-       if (arg_going)
-         {
-           obstack_1grow (&obstack, 0);
-           string = XOBFINISH (&obstack, const char *);
-           if (this_is_library_file)
-             string = find_file (string);
-           store_arg (string, delete_this_arg, this_is_output_file);
-           if (this_is_output_file)
-             outfiles[input_file_number] = string;
-         }
-       arg_going = 0;
+       end_going_arg ();
 
        if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
          {
 
        if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
          {
@@ -4549,17 +4734,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
        break;
 
       case '|':
        break;
 
       case '|':
-       /* End any pending argument.  */
-       if (arg_going)
-         {
-           obstack_1grow (&obstack, 0);
-           string = XOBFINISH (&obstack, const char *);
-           if (this_is_library_file)
-             string = find_file (string);
-           store_arg (string, delete_this_arg, this_is_output_file);
-           if (this_is_output_file)
-             outfiles[input_file_number] = string;
-         }
+       end_going_arg ();
 
        /* Use pipe */
        obstack_1grow (&obstack, c);
 
        /* Use pipe */
        obstack_1grow (&obstack, c);
@@ -4568,19 +4743,9 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
 
       case '\t':
       case ' ':
 
       case '\t':
       case ' ':
-       /* Space or tab ends an argument if one is pending.  */
-       if (arg_going)
-         {
-           obstack_1grow (&obstack, 0);
-           string = XOBFINISH (&obstack, const char *);
-           if (this_is_library_file)
-             string = find_file (string);
-           store_arg (string, delete_this_arg, this_is_output_file);
-           if (this_is_output_file)
-             outfiles[input_file_number] = string;
-         }
+       end_going_arg ();
+
        /* Reinitialize for a new argument.  */
        /* Reinitialize for a new argument.  */
-       arg_going = 0;
        delete_this_arg = 0;
        this_is_output_file = 0;
        this_is_library_file = 0;
        delete_this_arg = 0;
        this_is_output_file = 0;
        this_is_library_file = 0;
@@ -4611,23 +4776,23 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
             that we search for startfiles.  */
          case 'D':
            {
             that we search for startfiles.  */
          case 'D':
            {
-             struct prefix_list *pl = startfile_prefixes.plist;
+             struct spec_path_info info;
 
 
-             for (; pl; pl = pl->next)
-               {
-                 const char *no_suffix_multilib_dir;
-
-                 no_suffix_multilib_dir = pl->os_multilib ? multilib_os_dir
-                                          : multilib_dir;
-                 /* Do not separate options, include non-multilibbed variant.  */
-                 do_spec_path (pl, "-L",
+             info.option = "-L";
+             info.append_len = 0;
 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
-                               1,
+             /* Used on systems which record the specified -L dirs
+                and use them to search for dynamic linking.
+                Relative directories always come from -B,
+                and it is better not to use them for searching
+                at run time.  In particular, stage1 loses.  */
+             info.omit_relative = true;
 #else
 #else
-                               0,
+             info.omit_relative = false;
 #endif
 #endif
-                               0, 0, multilib_dir, no_suffix_multilib_dir);
-               }
+             info.separate_options = false;
+
+             for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
            }
            break;
 
            }
            break;
 
@@ -4639,7 +4804,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
              char *buf;
              while (*p != 0 && *p != '\n')
                p++;
              char *buf;
              while (*p != 0 && *p != '\n')
                p++;
-             buf = alloca (p - q + 1);
+             buf = (char *) alloca (p - q + 1);
              strncpy (buf, q, p - q);
              buf[p - q] = 0;
              error ("%s", buf);
              strncpy (buf, q, p - q);
              buf[p - q] = 0;
              error ("%s", buf);
@@ -4653,7 +4818,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
              char *buf;
              while (*p != 0 && *p != '\n')
                p++;
              char *buf;
              while (*p != 0 && *p != '\n')
                p++;
-             buf = alloca (p - q + 1);
+             buf = (char *) alloca (p - q + 1);
              strncpy (buf, q, p - q);
              buf[p - q] = 0;
              notice ("%s\n", buf);
              strncpy (buf, q, p - q);
              buf[p - q] = 0;
              notice ("%s\n", buf);
@@ -4691,7 +4856,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                arg_going = 1;
 
                /* consume suffix */
                arg_going = 1;
 
                /* consume suffix */
-               while (*p == '.' || ISALPHA ((unsigned char) *p))
+               while (*p == '.' || ISALNUM ((unsigned char) *p))
                  p++;
                if (p[0] == '%' && p[1] == 'O')
                  p += 2;
                  p++;
                if (p[0] == '%' && p[1] == 'O')
                  p += 2;
@@ -4703,7 +4868,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
            if (use_pipes)
              {
                /* consume suffix */
            if (use_pipes)
              {
                /* consume suffix */
-               while (*p == '.' || ISALPHA ((unsigned char) *p))
+               while (*p == '.' || ISALNUM ((unsigned char) *p))
                  p++;
                if (p[0] == '%' && p[1] == 'O')
                  p += 2;
                  p++;
                if (p[0] == '%' && p[1] == 'O')
                  p += 2;
@@ -4721,21 +4886,21 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                const char *suffix = p;
                char *saved_suffix = NULL;
 
                const char *suffix = p;
                char *saved_suffix = NULL;
 
-               while (*p == '.' || ISALPHA ((unsigned char) *p))
+               while (*p == '.' || ISALNUM ((unsigned char) *p))
                  p++;
                suffix_length = p - suffix;
                if (p[0] == '%' && p[1] == 'O')
                  {
                    p += 2;
                    /* We don't support extra suffix characters after %O.  */
                  p++;
                suffix_length = p - suffix;
                if (p[0] == '%' && p[1] == 'O')
                  {
                    p += 2;
                    /* We don't support extra suffix characters after %O.  */
-                   if (*p == '.' || ISALPHA ((unsigned char) *p))
+                   if (*p == '.' || ISALNUM ((unsigned char) *p))
                      fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
                    if (suffix_length == 0)
                      suffix = TARGET_OBJECT_SUFFIX;
                    else
                      {
                        saved_suffix
                      fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
                    if (suffix_length == 0)
                      suffix = TARGET_OBJECT_SUFFIX;
                    else
                      {
                        saved_suffix
-                         = xmalloc (suffix_length
+                         = XNEWVEC (char, suffix_length
                                     + strlen (TARGET_OBJECT_SUFFIX));
                        strncpy (saved_suffix, suffix, suffix_length);
                        strcpy (saved_suffix + suffix_length,
                                     + strlen (TARGET_OBJECT_SUFFIX));
                        strncpy (saved_suffix, suffix, suffix_length);
                        strcpy (saved_suffix + suffix_length,
@@ -4754,12 +4919,14 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
 
                if (save_temps_flag)
                  {
 
                if (save_temps_flag)
                  {
+                   char *tmp;
+                   
                    temp_filename_length = basename_length + suffix_length;
                    temp_filename_length = basename_length + suffix_length;
-                   temp_filename = alloca (temp_filename_length + 1);
-                   strncpy ((char *) temp_filename, input_basename, basename_length);
-                   strncpy ((char *) temp_filename + basename_length, suffix,
-                            suffix_length);
-                   *((char *) temp_filename + temp_filename_length) = '\0';
+                   tmp = (char *) alloca (temp_filename_length + 1);
+                   strncpy (tmp, input_basename, basename_length);
+                   strncpy (tmp + basename_length, suffix, suffix_length);
+                   tmp[temp_filename_length] = '\0';
+                   temp_filename = tmp;
                    if (strcmp (temp_filename, input_filename) != 0)
                      {
 #ifndef HOST_LACKS_INODE_NUMBERS
                    if (strcmp (temp_filename, input_filename) != 0)
                      {
 #ifndef HOST_LACKS_INODE_NUMBERS
@@ -4788,7 +4955,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                        bool files_differ = strcmp (input_realname, temp_realname);
                        free (input_realname);
                        free (temp_realname);
                        bool files_differ = strcmp (input_realname, temp_realname);
                        free (input_realname);
                        free (temp_realname);
-                       if (files_differ)       
+                       if (files_differ)
 #endif
                          {
                            temp_filename = save_string (temp_filename,
 #endif
                          {
                            temp_filename = save_string (temp_filename,
@@ -4816,7 +4983,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                  {
                    if (t == 0)
                      {
                  {
                    if (t == 0)
                      {
-                       t = xmalloc (sizeof (struct temp_name));
+                       t = XNEW (struct temp_name);
                        t->next = temp_names;
                        temp_names = t;
                      }
                        t->next = temp_names;
                        temp_names = t;
                      }
@@ -4864,7 +5031,16 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
 
          case 'I':
            {
 
          case 'I':
            {
-             struct prefix_list *pl = include_prefixes.plist;
+             struct spec_path_info info;
+
+             if (multilib_dir)
+               {
+                 do_spec_1 ("-imultilib", 1, NULL);
+                 /* Make this a separate argument.  */
+                 do_spec_1 (" ", 0, NULL);
+                 do_spec_1 (multilib_dir, 1, NULL);
+                 do_spec_1 (" ", 0, NULL);
+               }
 
              if (gcc_exec_prefix)
                {
 
              if (gcc_exec_prefix)
                {
@@ -4887,9 +5063,22 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                  do_spec_1 (" ", 0, NULL);
                }
 
                  do_spec_1 (" ", 0, NULL);
                }
 
-             for (; pl; pl = pl->next)
-               /* Separate options, don't include non-suffixed variant.  */
-               do_spec_path (pl, "-isystem", 0, 1, 1, "include", "include");
+             info.option = "-isystem";
+             info.append = "include";
+             info.append_len = strlen (info.append);
+             info.omit_relative = false;
+             info.separate_options = true;
+
+             for_each_path (&include_prefixes, false, info.append_len,
+                            spec_path, &info);
+
+             info.append = "include-fixed";
+             if (*sysroot_hdrs_suffix_spec)
+               info.append = concat (info.append, dir_separator_str,
+                                     multilib_dir, NULL);
+             info.append_len = strlen (info.append);
+             for_each_path (&include_prefixes, false, info.append_len,
+                            spec_path, &info);
            }
            break;
 
            }
            break;
 
@@ -4898,9 +5087,63 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
              int max = n_infiles;
              max += lang_specific_extra_outfiles;
 
              int max = n_infiles;
              max += lang_specific_extra_outfiles;
 
-             for (i = 0; i < max; i++)
-               if (outfiles[i])
-                 store_arg (outfiles[i], 0, 0);
+              if (HAVE_GNU_LD && at_file_supplied)
+                {
+                  /* We are going to expand `%o' to `@FILE', where FILE
+                     is a newly-created temporary filename.  The filenames
+                     that would usually be expanded in place of %o will be
+                     written to the temporary file.  */
+
+                  char *temp_file = make_temp_file ("");
+                  char *at_argument;
+                  char **argv;
+                  int n_files, j, status;
+                  FILE *f;
+
+                  at_argument = concat ("@", temp_file, NULL);
+                  store_arg (at_argument, 0, 0);
+
+                  /* Convert OUTFILES into a form suitable for writeargv.  */
+
+                  /* Determine how many are non-NULL.  */
+                  for (n_files = 0, i = 0; i < max; i++)
+                    n_files += outfiles[i] != NULL;
+
+                  argv = (char **) alloca (sizeof (char *) * (n_files + 1));
+
+                  /* Copy the strings over.  */
+                  for (i = 0, j = 0; i < max; i++)
+                    if (outfiles[i])
+                      {
+                        argv[j] = CONST_CAST (char *, outfiles[i]);
+                        j++;
+                      }
+                  argv[j] = NULL;
+
+                  f = fopen (temp_file, "w");
+
+                  if (f == NULL)
+                    fatal ("could not open temporary response file %s",
+                           temp_file);
+
+                  status = writeargv (argv, f);
+
+                  if (status)
+                    fatal ("could not write to temporary response file %s",
+                           temp_file);
+
+                  status = fclose (f);
+
+                  if (EOF == status)
+                    fatal ("could not close temporary response file %s",
+                           temp_file);
+
+                  record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
+                }
+              else
+                for (i = 0; i < max; i++)
+                 if (outfiles[i])
+                   store_arg (outfiles[i], 0, 0);
              break;
            }
 
              break;
            }
 
@@ -4930,18 +5173,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
              p = handle_braces (p + 1);
              if (p == 0)
                return -1;
              p = handle_braces (p + 1);
              if (p == 0)
                return -1;
-             /* End any pending argument.  */
-             if (arg_going)
-               {
-                 obstack_1grow (&obstack, 0);
-                 string = XOBFINISH (&obstack, const char *);
-                 if (this_is_library_file)
-                   string = find_file (string);
-                 store_arg (string, delete_this_arg, this_is_output_file);
-                 if (this_is_output_file)
-                   outfiles[input_file_number] = string;
-                 arg_going = 0;
-               }
+             end_going_arg ();
              /* If any args were output, mark the last one for deletion
                 on failure.  */
              if (argbuf_index != cur_index)
              /* If any args were output, mark the last one for deletion
                 on failure.  */
              if (argbuf_index != cur_index)
@@ -5134,7 +5366,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                if (!strncmp (switches[i].part1, p, len - have_wildcard)
                    && (have_wildcard || switches[i].part1[len] == '\0'))
                  {
                if (!strncmp (switches[i].part1, p, len - have_wildcard)
                    && (have_wildcard || switches[i].part1[len] == '\0'))
                  {
-                   switches[i].live_cond = SWITCH_IGNORE;
+                   switches[i].live_cond |= SWITCH_IGNORE;
                    switches[i].validated = 1;
                  }
 
                    switches[i].validated = 1;
                  }
 
@@ -5195,7 +5427,7 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
                    }
                  else
                    {
                    }
                  else
                    {
-                     char *x = alloca (strlen (name) * 2 + 1);
+                     char *x = (char *) alloca (strlen (name) * 2 + 1);
                      char *buf = x;
                      const char *y = name;
                      int flag = 0;
                      char *buf = x;
                      const char *y = name;
                      int flag = 0;
@@ -5260,17 +5492,8 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
 
   /* End of string.  If we are processing a spec function, we need to
      end any pending argument.  */
 
   /* End of string.  If we are processing a spec function, we need to
      end any pending argument.  */
-  if (processing_spec_function && arg_going)
-    {
-      obstack_1grow (&obstack, 0);
-      string = XOBFINISH (&obstack, const char *);
-      if (this_is_library_file)
-        string = find_file (string);
-      store_arg (string, delete_this_arg, this_is_output_file);
-      if (this_is_output_file)
-        outfiles[input_file_number] = string;
-      arg_going = 0;
-    }
+  if (processing_spec_function)
+    end_going_arg ();
 
   return 0;
 }
 
   return 0;
 }
@@ -5280,20 +5503,11 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
 static const struct spec_function *
 lookup_spec_function (const char *name)
 {
 static const struct spec_function *
 lookup_spec_function (const char *name)
 {
-  static const struct spec_function * const spec_function_tables[] =
-  {
-    static_spec_functions,
-    lang_specific_spec_functions,
-  };
   const struct spec_function *sf;
   const struct spec_function *sf;
-  unsigned int i;
 
 
-  for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
-    {
-      for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
-       if (strcmp (sf->name, name) == 0)
-         return sf;
-    }
+  for (sf = static_spec_functions; sf->name != NULL; sf++)
+    if (strcmp (sf->name, name) == 0)
+      return sf;
 
   return NULL;
 }
 
   return NULL;
 }
@@ -5433,31 +5647,28 @@ handle_spec_function (const char *p)
 static inline bool
 input_suffix_matches (const char *atom, const char *end_atom)
 {
 static inline bool
 input_suffix_matches (const char *atom, const char *end_atom)
 {
-  /* We special case the semantics of {.s:...} and {.S:...} and their
-     negative variants.  Instead of testing the input filename suffix,
-     we test whether the input source file is an assembler file or an
-     assembler-with-cpp file respectively.  This allows us to correctly
-     handle the -x command line option.  */
-
-  if (atom + 1 == end_atom
-      && input_file_compiler
-      && input_file_compiler->suffix)
-    {
-      if (*atom == 's')
-       return !strcmp (input_file_compiler->suffix, "@assembler");
-      if (*atom == 'S')
-       return !strcmp (input_file_compiler->suffix, "@assembler-with-cpp");
-    }
-
   return (input_suffix
          && !strncmp (input_suffix, atom, end_atom - atom)
          && input_suffix[end_atom - atom] == '\0');
 }
 
   return (input_suffix
          && !strncmp (input_suffix, atom, end_atom - atom)
          && input_suffix[end_atom - atom] == '\0');
 }
 
-/* Inline subroutine of handle_braces.  Returns true if a switch
+/* Subroutine of handle_braces.  Returns true if the current
+   input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
+static bool
+input_spec_matches (const char *atom, const char *end_atom)
+{
+  return (input_file_compiler
+         && input_file_compiler->suffix
+         && input_file_compiler->suffix[0] != '\0'
+         && !strncmp (input_file_compiler->suffix + 1, atom,
+                      end_atom - atom)
+         && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
+}
+
+/* Subroutine of handle_braces.  Returns true if a switch
    matching the atom bracketed by ATOM and END_ATOM appeared on the
    command line.  */
    matching the atom bracketed by ATOM and END_ATOM appeared on the
    command line.  */
-static inline bool
+static bool
 switch_matches (const char *atom, const char *end_atom, int starred)
 {
   int i;
 switch_matches (const char *atom, const char *end_atom, int starred)
 {
   int i;
@@ -5517,6 +5728,7 @@ handle_braces (const char *p)
   const char *orig = p;
 
   bool a_is_suffix;
   const char *orig = p;
 
   bool a_is_suffix;
+  bool a_is_spectype;
   bool a_is_starred;
   bool a_is_negated;
   bool a_matched;
   bool a_is_starred;
   bool a_is_negated;
   bool a_matched;
@@ -5537,8 +5749,12 @@ handle_braces (const char *p)
        goto invalid;
 
       /* Scan one "atom" (S in the description above of %{}, possibly
        goto invalid;
 
       /* Scan one "atom" (S in the description above of %{}, possibly
-        with !, ., or * modifiers).  */
-      a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
+        with '!', '.', '@', ',', or '*' modifiers).  */
+      a_matched = false;
+      a_is_suffix = false;
+      a_is_starred = false;
+      a_is_negated = false;
+      a_is_spectype = false;
 
       SKIP_WHITE();
       if (*p == '!')
 
       SKIP_WHITE();
       if (*p == '!')
@@ -5547,6 +5763,8 @@ handle_braces (const char *p)
       SKIP_WHITE();
       if (*p == '.')
        p++, a_is_suffix = true;
       SKIP_WHITE();
       if (*p == '.')
        p++, a_is_suffix = true;
+      else if (*p == ',')
+       p++, a_is_spectype = true;
 
       atom = p;
       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
 
       atom = p;
       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
@@ -5564,7 +5782,7 @@ handle_braces (const char *p)
          /* Substitute the switch(es) indicated by the current atom.  */
          ordered_set = true;
          if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
          /* Substitute the switch(es) indicated by the current atom.  */
          ordered_set = true;
          if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
-             || atom == end_atom)
+             || a_is_spectype || atom == end_atom)
            goto invalid;
 
          mark_matching_switches (atom, end_atom, a_is_starred);
            goto invalid;
 
          mark_matching_switches (atom, end_atom, a_is_starred);
@@ -5583,7 +5801,8 @@ handle_braces (const char *p)
          if (atom == end_atom)
            {
              if (!n_way_choice || disj_matched || *p == '|'
          if (atom == end_atom)
            {
              if (!n_way_choice || disj_matched || *p == '|'
-                 || a_is_negated || a_is_suffix || a_is_starred)
+                 || a_is_negated || a_is_suffix || a_is_spectype 
+                 || a_is_starred)
                goto invalid;
 
              /* An empty term may appear as the last choice of an
                goto invalid;
 
              /* An empty term may appear as the last choice of an
@@ -5594,28 +5813,30 @@ handle_braces (const char *p)
            }
          else
            {
            }
          else
            {
-              if (a_is_suffix && a_is_starred)
-                goto invalid;
-
-              if (!a_is_starred)
-                disj_starred = false;
-
-              /* Don't bother testing this atom if we already have a
-                  match.  */
-              if (!disj_matched && !n_way_matched)
-                {
-                  if (a_is_suffix)
-                    a_matched = input_suffix_matches (atom, end_atom);
-                  else
-                    a_matched = switch_matches (atom, end_atom, a_is_starred);
-
-                  if (a_matched != a_is_negated)
-                    {
-                      disj_matched = true;
-                      d_atom = atom;
-                      d_end_atom = end_atom;
-                    }
-                }
+             if ((a_is_suffix || a_is_spectype) && a_is_starred)
+               goto invalid;
+             
+             if (!a_is_starred)
+               disj_starred = false;
+
+             /* Don't bother testing this atom if we already have a
+                match.  */
+             if (!disj_matched && !n_way_matched)
+               {
+                 if (a_is_suffix)
+                   a_matched = input_suffix_matches (atom, end_atom);
+                 else if (a_is_spectype)
+                   a_matched = input_spec_matches (atom, end_atom);
+                 else
+                   a_matched = switch_matches (atom, end_atom, a_is_starred);
+                 
+                 if (a_matched != a_is_negated)
+                   {
+                     disj_matched = true;
+                     d_atom = atom;
+                     d_end_atom = end_atom;
+                   }
+               }
            }
 
          if (*p == ':')
            }
 
          if (*p == ':')
@@ -5647,10 +5868,10 @@ handle_braces (const char *p)
   while (*p++ != '}');
 
   return p;
   while (*p++ != '}');
 
   return p;
-  
+
  invalid:
   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
  invalid:
   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
-  
+
 #undef SKIP_WHITE
 }
 
 #undef SKIP_WHITE
 }
 
@@ -5763,7 +5984,8 @@ check_live_switch (int switchnum, int prefix_length)
   /* If we already processed this switch and determined if it was
      live or not, return our past determination.  */
   if (switches[switchnum].live_cond != 0)
   /* If we already processed this switch and determined if it was
      live or not, return our past determination.  */
   if (switches[switchnum].live_cond != 0)
-    return switches[switchnum].live_cond > 0;
+    return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
+           && (switches[switchnum].live_cond & SWITCH_FALSE) == 0);
 
   /* Now search for duplicate in a manner that depends on the name.  */
   switch (*name)
 
   /* Now search for duplicate in a manner that depends on the name.  */
   switch (*name)
@@ -5810,7 +6032,7 @@ check_live_switch (int switchnum, int prefix_length)
     }
 
   /* Otherwise the switch is live.  */
     }
 
   /* Otherwise the switch is live.  */
-  switches[switchnum].live_cond = SWITCH_LIVE;
+  switches[switchnum].live_cond |= SWITCH_LIVE;
   return 1;
 }
 \f
   return 1;
 }
 \f
@@ -5825,7 +6047,7 @@ check_live_switch (int switchnum, int prefix_length)
 static void
 give_switch (int switchnum, int omit_first_word)
 {
 static void
 give_switch (int switchnum, int omit_first_word)
 {
-  if (switches[switchnum].live_cond == SWITCH_IGNORE)
+  if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
     return;
 
   if (!omit_first_word)
     return;
 
   if (!omit_first_word)
@@ -5850,13 +6072,13 @@ give_switch (int switchnum, int omit_first_word)
              while (length-- && !IS_DIR_SEPARATOR (arg[length]))
                if (arg[length] == '.')
                  {
              while (length-- && !IS_DIR_SEPARATOR (arg[length]))
                if (arg[length] == '.')
                  {
-                   ((char *)arg)[length] = 0;
+                   (CONST_CAST(char *, arg))[length] = 0;
                    dot = 1;
                    break;
                  }
              do_spec_1 (arg, 1, NULL);
              if (dot)
                    dot = 1;
                    break;
                  }
              do_spec_1 (arg, 1, NULL);
              if (dot)
-               ((char *)arg)[length] = '.';
+               (CONST_CAST(char *, arg))[length] = '.';
              do_spec_1 (suffix_subst, 1, NULL);
            }
          else
              do_spec_1 (suffix_subst, 1, NULL);
            }
          else
@@ -5875,48 +6097,27 @@ give_switch (int switchnum, int omit_first_word)
 static const char *
 find_file (const char *name)
 {
 static const char *
 find_file (const char *name)
 {
-  char *newname;
-
-  /* Try multilib_dir if it is defined.  */
-  if (multilib_os_dir != NULL)
-    {
-      newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
-
-      /* If we don't find it in the multi library dir, then fall
-        through and look for it in the normal places.  */
-      if (newname != NULL)
-       return newname;
-    }
-
-  newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
+  char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
   return newname ? newname : name;
 }
 
 /* Determine whether a directory exists.  If LINKER, return 0 for
   return newname ? newname : name;
 }
 
 /* Determine whether a directory exists.  If LINKER, return 0 for
-   certain fixed names not needed by the linker.  If not LINKER, it is
-   only important to return 0 if the host machine has a small ARG_MAX
-   limit.  */
+   certain fixed names not needed by the linker.  */
 
 static int
 
 static int
-is_directory (const char *path1, const char *path2, int linker)
+is_directory (const char *path1, bool linker)
 {
 {
-  int len1 = strlen (path1);
-  int len2 = strlen (path2);
-  char *path = alloca (3 + len1 + len2);
+  int len1;
+  char *path;
   char *cp;
   struct stat st;
 
   char *cp;
   struct stat st;
 
-#ifndef SMALL_ARG_MAX
-  if (! linker)
-    return 1;
-#endif
-
-  /* Construct the path from the two parts.  Ensure the string ends with "/.".
-     The resulting path will be a directory even if the given path is a
-     symbolic link.  */
+  /* Ensure the string ends with "/.".  The resulting path will be a
+     directory even if the given path is a symbolic link.  */
+  len1 = strlen (path1);
+  path = (char *) alloca (3 + len1);
   memcpy (path, path1, len1);
   memcpy (path, path1, len1);
-  memcpy (path + len1, path2, len2);
-  cp = path + len1 + len2;
+  cp = path + len1;
   if (!IS_DIR_SEPARATOR (cp[-1]))
     *cp++ = DIR_SEPARATOR;
   *cp++ = '.';
   if (!IS_DIR_SEPARATOR (cp[-1]))
     *cp++ = DIR_SEPARATOR;
   *cp++ = '.';
@@ -5924,13 +6125,13 @@ is_directory (const char *path1, const char *path2, int linker)
 
   /* Exclude directories that the linker is known to search.  */
   if (linker
 
   /* Exclude directories that the linker is known to search.  */
   if (linker
+      && IS_DIR_SEPARATOR (path[0])
       && ((cp - path == 6
       && ((cp - path == 6
-          && strcmp (path, concat (dir_separator_str, "lib",
-                                   dir_separator_str, ".", NULL)) == 0)
+          && strncmp (path + 1, "lib", 3) == 0)
          || (cp - path == 10
          || (cp - path == 10
-             && strcmp (path, concat (dir_separator_str, "usr",
-                                      dir_separator_str, "lib",
-                                      dir_separator_str, ".", NULL)) == 0)))
+             && strncmp (path + 1, "usr", 3) == 0
+             && IS_DIR_SEPARATOR (path[4])
+             && strncmp (path + 5, "lib", 3) == 0)))
     return 0;
 
   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
     return 0;
 
   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
@@ -5991,10 +6192,10 @@ fatal_error (int signum)
   kill (getpid (), signum);
 }
 
   kill (getpid (), signum);
 }
 
-extern int main (int, const char **);
+extern int main (int, char **);
 
 int
 
 int
-main (int argc, const char **argv)
+main (int argc, char **argv)
 {
   size_t i;
   int value;
 {
   size_t i;
   int value;
@@ -6005,6 +6206,11 @@ main (int argc, const char **argv)
   char *specs_file;
   const char *p;
   struct user_specs *uptr;
   char *specs_file;
   const char *p;
   struct user_specs *uptr;
+  char **old_argv = argv;
+
+  /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
+     on ?: in file-scope variable initializations.  */
+  asm_debug = ASM_DEBUG_SPEC;
 
   p = argv[0] + strlen (argv[0]);
   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
 
   p = argv[0] + strlen (argv[0]);
   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
@@ -6013,6 +6219,14 @@ main (int argc, const char **argv)
 
   xmalloc_set_program_name (programname);
 
 
   xmalloc_set_program_name (programname);
 
+  expandargv (&argc, &argv);
+
+  /* Determine if any expansions were made.  */
+  if (argv != old_argv)
+    at_file_supplied = true;
+
+  prune_options (&argc, &argv);
+
 #ifdef GCC_DRIVER_HOST_INITIALIZATION
   /* Perform host dependent initialization when needed.  */
   GCC_DRIVER_HOST_INITIALIZATION;
 #ifdef GCC_DRIVER_HOST_INITIALIZATION
   /* Perform host dependent initialization when needed.  */
   GCC_DRIVER_HOST_INITIALIZATION;
@@ -6094,23 +6308,23 @@ main (int argc, const char **argv)
   obstack_init (&collect_obstack);
   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
   obstack_init (&collect_obstack);
   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
-  putenv (XOBFINISH (&collect_obstack, char *));
+  xputenv (XOBFINISH (&collect_obstack, char *));
 
 #ifdef INIT_ENVIRONMENT
   /* Set up any other necessary machine specific environment variables.  */
 
 #ifdef INIT_ENVIRONMENT
   /* Set up any other necessary machine specific environment variables.  */
-  putenv (INIT_ENVIRONMENT);
+  xputenv (INIT_ENVIRONMENT);
 #endif
 
   /* Make a table of what switches there are (switches, n_switches).
      Make a table of specified input files (infiles, n_infiles).
      Decode switches that are handled locally.  */
 
 #endif
 
   /* Make a table of what switches there are (switches, n_switches).
      Make a table of specified input files (infiles, n_infiles).
      Decode switches that are handled locally.  */
 
-  process_command (argc, argv);
+  process_command (argc, (const char **) argv);
 
   /* Initialize the vector of specs to just the default.
      This means one element containing 0s, as a terminator.  */
 
 
   /* Initialize the vector of specs to just the default.
      This means one element containing 0s, as a terminator.  */
 
-  compilers = xmalloc (sizeof default_compilers);
+  compilers = XNEWVAR (struct compiler, sizeof default_compilers);
   memcpy (compilers, default_compilers, sizeof default_compilers);
   n_compilers = n_default_compilers;
 
   memcpy (compilers, default_compilers, sizeof default_compilers);
   n_compilers = n_default_compilers;
 
@@ -6120,7 +6334,7 @@ main (int argc, const char **argv)
                           spec_version, dir_separator_str, NULL);
   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
 
                           spec_version, dir_separator_str, NULL);
   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
 
-  specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
+  specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
   /* Read the specs file unless it is a default one.  */
   if (specs_file != 0 && strcmp (specs_file, "specs"))
     read_specs (specs_file, TRUE);
   /* Read the specs file unless it is a default one.  */
   if (specs_file != 0 && strcmp (specs_file, "specs"))
     read_specs (specs_file, TRUE);
@@ -6129,7 +6343,7 @@ main (int argc, const char **argv)
 
   /* We need to check standard_exec_prefix/just_machine_suffix/specs
      for any override of as, ld and libraries.  */
 
   /* We need to check standard_exec_prefix/just_machine_suffix/specs
      for any override of as, ld and libraries.  */
-  specs_file = alloca (strlen (standard_exec_prefix)
+  specs_file = (char *) alloca (strlen (standard_exec_prefix)
                       + strlen (just_machine_suffix) + sizeof ("specs"));
 
   strcpy (specs_file, standard_exec_prefix);
                       + strlen (just_machine_suffix) + sizeof ("specs"));
 
   strcpy (specs_file, standard_exec_prefix);
@@ -6229,18 +6443,16 @@ main (int argc, const char **argv)
                              PREFIX_PRIORITY_LAST, 0, 1);
       else if (*cross_compile == '0')
        {
                              PREFIX_PRIORITY_LAST, 0, 1);
       else if (*cross_compile == '0')
        {
-         if (gcc_exec_prefix)
-           add_prefix (&startfile_prefixes,
-                       concat (gcc_exec_prefix, machine_suffix,
-                               standard_startfile_prefix, NULL),
-                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
          add_prefix (&startfile_prefixes,
          add_prefix (&startfile_prefixes,
-                     concat (standard_exec_prefix,
-                             machine_suffix,
+                     concat (gcc_exec_prefix 
+                             ? gcc_exec_prefix : standard_exec_prefix, 
+                             machine_suffix, 
                              standard_startfile_prefix, NULL),
                      NULL, PREFIX_PRIORITY_LAST, 0, 1);
        }
 
                              standard_startfile_prefix, NULL),
                      NULL, PREFIX_PRIORITY_LAST, 0, 1);
        }
 
+      /* Sysrooted prefixes are relocated because target_system_root is
+        also relocated by gcc_exec_prefix.  */
       if (*standard_startfile_prefix_1)
        add_sysrooted_prefix (&startfile_prefixes,
                              standard_startfile_prefix_1, "BINUTILS",
       if (*standard_startfile_prefix_1)
        add_sysrooted_prefix (&startfile_prefixes,
                              standard_startfile_prefix_1, "BINUTILS",
@@ -6256,7 +6468,7 @@ main (int argc, const char **argv)
   for (uptr = user_specs_head; uptr; uptr = uptr->next)
     {
       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
   for (uptr = user_specs_head; uptr; uptr = uptr->next)
     {
       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
-                                   R_OK, 0);
+                                   R_OK, true);
       read_specs (filename ? filename : uptr->filename, FALSE);
     }
 
       read_specs (filename ? filename : uptr->filename, FALSE);
     }
 
@@ -6284,9 +6496,13 @@ main (int argc, const char **argv)
 
   if (print_search_dirs)
     {
 
   if (print_search_dirs)
     {
-      printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
-      printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
-      printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
+      printf (_("install: %s%s\n"),
+             gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
+             gcc_exec_prefix ? "" : machine_suffix);
+      printf (_("programs: %s\n"),
+             build_search_list (&exec_prefixes, "", false, false));
+      printf (_("libraries: %s\n"),
+             build_search_list (&startfile_prefixes, "", false, true));
       return (0);
     }
 
       return (0);
     }
 
@@ -6318,6 +6534,18 @@ main (int argc, const char **argv)
       return (0);
     }
 
       return (0);
     }
 
+  if (print_sysroot)
+    {
+      if (target_system_root)
+       {
+          if (target_sysroot_suffix)
+           printf ("%s%s\n", target_system_root, target_sysroot_suffix);
+          else
+           printf ("%s\n", target_system_root);
+       }
+      return (0);
+    }
+
   if (print_multi_os_directory)
     {
       if (multilib_os_dir == NULL)
   if (print_multi_os_directory)
     {
       if (multilib_os_dir == NULL)
@@ -6327,14 +6555,19 @@ main (int argc, const char **argv)
       return (0);
     }
 
       return (0);
     }
 
-  if (target_help_flag)
-   {
-      /* Print if any target specific options.  */
-
-      /* We do not exit here. Instead we have created a fake input file
-         called 'target-dummy' which needs to be compiled, and we pass this
-         on to the various sub-processes, along with the --target-help
-         switch.  */
+  if (print_sysroot_headers_suffix)
+    {
+      if (*sysroot_hdrs_suffix_spec)
+       {
+         printf("%s\n", (target_sysroot_hdrs_suffix
+                         ? target_sysroot_hdrs_suffix
+                         : ""));
+         return (0);
+       }
+      else
+       /* The error status indicates that only one set of fixed
+          headers should be built.  */
+       fatal ("not configured with sysroot headers suffix");
     }
 
   if (print_help_list)
     }
 
   if (print_help_list)
@@ -6385,10 +6618,10 @@ main (int argc, const char **argv)
 
       if (! strncmp (version_string, compiler_version, n)
          && compiler_version[n] == 0)
 
       if (! strncmp (version_string, compiler_version, n)
          && compiler_version[n] == 0)
-       notice ("gcc version %s\n", version_string);
+       notice ("gcc version %s %s\n", version_string, pkgversion_string);
       else
       else
-       notice ("gcc driver version %s executing gcc version %s\n",
-               version_string, compiler_version);
+       notice ("gcc driver version %s %sexecuting gcc version %s\n",
+               version_string, pkgversion_string, compiler_version);
 
       if (n_infiles == 0)
        return (0);
 
       if (n_infiles == 0)
        return (0);
@@ -6402,11 +6635,11 @@ main (int argc, const char **argv)
 
   i = n_infiles;
   i += lang_specific_extra_outfiles;
 
   i = n_infiles;
   i += lang_specific_extra_outfiles;
-  outfiles = xcalloc (i, sizeof (char *));
+  outfiles = XCNEWVEC (const char *, i);
 
   /* Record which files were specified explicitly as link input.  */
 
 
   /* Record which files were specified explicitly as link input.  */
 
-  explicit_link_files = xcalloc (1, n_infiles);
+  explicit_link_files = XCNEWVEC (char, n_infiles);
 
   if (combine_flag)
     combine_inputs = true;
 
   if (combine_flag)
     combine_inputs = true;
@@ -6416,13 +6649,13 @@ main (int argc, const char **argv)
   for (i = 0; (int) i < n_infiles; i++)
     {
       const char *name = infiles[i].name;
   for (i = 0; (int) i < n_infiles; i++)
     {
       const char *name = infiles[i].name;
-      struct compiler *compiler = lookup_compiler (name, 
-                                                  strlen (name), 
+      struct compiler *compiler = lookup_compiler (name,
+                                                  strlen (name),
                                                   infiles[i].language);
                                                   infiles[i].language);
-      
+
       if (compiler && !(compiler->combinable))
        combine_inputs = false;
       if (compiler && !(compiler->combinable))
        combine_inputs = false;
-      
+
       if (lang_n_infiles > 0 && compiler != input_file_compiler
          && infiles[i].language && infiles[i].language[0] != '*')
        infiles[i].incompiler = compiler;
       if (lang_n_infiles > 0 && compiler != input_file_compiler
          && infiles[i].language && infiles[i].language[0] != '*')
        infiles[i].incompiler = compiler;
@@ -6442,7 +6675,10 @@ main (int argc, const char **argv)
       infiles[i].compiled = false;
       infiles[i].preprocessed = false;
     }
       infiles[i].compiled = false;
       infiles[i].preprocessed = false;
     }
-  
+
+  if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
+   fatal ("cannot specify -o with -c or -S with multiple files");
+
   if (combine_flag && save_temps_flag)
     {
       bool save_combine_inputs = combine_inputs;
   if (combine_flag && save_temps_flag)
     {
       bool save_combine_inputs = combine_inputs;
@@ -6453,7 +6689,7 @@ main (int argc, const char **argv)
       for (i = 0; (int) i < n_infiles; i++)
        {
          int this_file_error = 0;
       for (i = 0; (int) i < n_infiles; i++)
        {
          int this_file_error = 0;
-         
+
          input_file_number = i;
          set_input (infiles[i].name);
          if (infiles[i].incompiler
          input_file_number = i;
          set_input (infiles[i].name);
          if (infiles[i].incompiler
@@ -6562,7 +6798,7 @@ main (int argc, const char **argv)
 
   /* Reset the input file name to the first compile/object file name, for use
      with %b in LINK_SPEC. We use the first input file that we can find
 
   /* Reset the input file name to the first compile/object file name, for use
      with %b in LINK_SPEC. We use the first input file that we can find
-     a compiler to compile it instead of using infiles.language since for 
+     a compiler to compile it instead of using infiles.language since for
      languages other than C we use aliases that we then lookup later.  */
   if (n_infiles > 0)
     {
      languages other than C we use aliases that we then lookup later.  */
   if (n_infiles > 0)
     {
@@ -6593,22 +6829,29 @@ main (int argc, const char **argv)
 
   /* Run ld to link all the compiler output files.  */
 
 
   /* Run ld to link all the compiler output files.  */
 
-  if (num_linker_inputs > 0 && error_count == 0)
+  if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
     {
       int tmp = execution_count;
 
       /* We'll use ld if we can't find collect2.  */
       if (! strcmp (linker_name_spec, "collect2"))
        {
     {
       int tmp = execution_count;
 
       /* We'll use ld if we can't find collect2.  */
       if (! strcmp (linker_name_spec, "collect2"))
        {
-         char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0);
+         char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
          if (s == NULL)
            linker_name_spec = "ld";
        }
       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
         for collect.  */
          if (s == NULL)
            linker_name_spec = "ld";
        }
       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
         for collect.  */
-      putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
-      putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
+      putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
+      putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
 
 
+      if (print_subprocess_help == 1)
+       {
+         printf (_("\nLinker options\n==============\n\n"));
+         printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
+                   " to the linker.\n\n"));
+         fflush (stdout);
+       }
       value = do_spec (link_command_spec);
       if (value < 0)
        error_count = 1;
       value = do_spec (link_command_spec);
       if (value < 0)
        error_count = 1;
@@ -6620,7 +6863,8 @@ main (int argc, const char **argv)
 
   if (! linker_was_run && error_count == 0)
     for (i = 0; (int) i < n_infiles; i++)
 
   if (! linker_was_run && error_count == 0)
     for (i = 0; (int) i < n_infiles; i++)
-      if (explicit_link_files[i])
+      if (explicit_link_files[i]
+         && !(infiles[i].language && infiles[i].language[0] == '*'))
        error ("%s: linker input file unused because linking not done",
               outfiles[i]);
 
        error ("%s: linker input file unused because linking not done",
               outfiles[i]);
 
@@ -6714,7 +6958,7 @@ lookup_compiler (const char *name, size_t length, const char *language)
 static char *
 save_string (const char *s, int len)
 {
 static char *
 save_string (const char *s, int len)
 {
-  char *result = xmalloc (len + 1);
+  char *result = XNEWVEC (char, len + 1);
 
   memcpy (result, s, len);
   result[len] = 0;
 
   memcpy (result, s, len);
   result[len] = 0;
@@ -6740,12 +6984,27 @@ perror_with_name (const char *name)
 void
 fancy_abort (const char *file, int line, const char *func)
 {
 void
 fancy_abort (const char *file, int line, const char *func)
 {
-  fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
+  fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
 }
 \f
 /* Output an error message and exit.  */
 
 void
 }
 \f
 /* Output an error message and exit.  */
 
 void
+fatal_ice (const char *cmsgid, ...)
+{
+  va_list ap;
+
+  va_start (ap, cmsgid);
+
+  fprintf (stderr, "%s: ", programname);
+  vfprintf (stderr, _(cmsgid), ap);
+  va_end (ap);
+  fprintf (stderr, "\n");
+  delete_temp_files ();
+  exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
+}
+
+void
 fatal (const char *cmsgid, ...)
 {
   va_list ap;
 fatal (const char *cmsgid, ...)
 {
   va_list ap;
@@ -6838,7 +7097,7 @@ next_member:
     p++;
 
   SKIP_WHITE ();
     p++;
 
   SKIP_WHITE ();
-  if (*p == '.')
+  if (*p == '.' || *p == ',')
     suffix = true, p++;
 
   atom = p;
     suffix = true, p++;
 
   atom = p;
@@ -6929,7 +7188,8 @@ used_arg (const char *p, int len)
        if (*q == ';')
          cnt++;
 
        if (*q == ';')
          cnt++;
 
-      matches = alloca ((sizeof (struct mswitchstr)) * cnt);
+      matches
+       = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
       i = 0;
       q = multilib_matches;
       while (*q != '\0')
       i = 0;
       q = multilib_matches;
       while (*q != '\0')
@@ -6964,10 +7224,9 @@ used_arg (const char *p, int len)
         xmalloc from calling fatal, and prevents us from re-executing this
         block of code.  */
       mswitches
         xmalloc from calling fatal, and prevents us from re-executing this
         block of code.  */
       mswitches
-       = xmalloc (sizeof (struct mswitchstr)
-                  * (n_mdswitches + (n_switches ? n_switches : 1)));
+       = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
       for (i = 0; i < n_switches; i++)
       for (i = 0; i < n_switches; i++)
-       if (switches[i].live_cond != SWITCH_IGNORE)
+       if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
          {
            int xlen = strlen (switches[i].part1);
            for (j = 0; j < cnt; j++)
          {
            int xlen = strlen (switches[i].part1);
            for (j = 0; j < cnt; j++)
@@ -7092,7 +7351,7 @@ set_multilib_dir (void)
     {
       int i = 0;
 
     {
       int i = 0;
 
-      mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches);
+      mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
       for (start = multilib_defaults; *start != '\0'; start = end + 1)
        {
          while (*start == ' ' || *start == '\t')
       for (start = multilib_defaults; *start != '\0'; start = end + 1)
        {
          while (*start == ' ' || *start == '\t')
@@ -7254,7 +7513,7 @@ set_multilib_dir (void)
          if (this_path_len != 1
              || this_path[0] != '.')
            {
          if (this_path_len != 1
              || this_path[0] != '.')
            {
-             char *new_multilib_dir = xmalloc (this_path_len + 1);
+             char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
              char *q;
 
              strncpy (new_multilib_dir, this_path, this_path_len);
              char *q;
 
              strncpy (new_multilib_dir, this_path, this_path_len);
@@ -7275,7 +7534,7 @@ set_multilib_dir (void)
            q++;
          if (q < end)
            {
            q++;
          if (q < end)
            {
-             char *new_multilib_os_dir = xmalloc (end - q);
+             char *new_multilib_os_dir = XNEWVEC (char, end - q);
              memcpy (new_multilib_os_dir, q + 1, end - q - 1);
              new_multilib_os_dir[end - q - 1] = '\0';
              multilib_os_dir = new_multilib_os_dir;
              memcpy (new_multilib_os_dir, q + 1, end - q - 1);
              new_multilib_os_dir[end - q - 1] = '\0';
              multilib_os_dir = new_multilib_os_dir;
@@ -7289,7 +7548,7 @@ set_multilib_dir (void)
   if (multilib_dir == NULL && multilib_os_dir != NULL
       && strcmp (multilib_os_dir, ".") == 0)
     {
   if (multilib_dir == NULL && multilib_os_dir != NULL
       && strcmp (multilib_os_dir, ".") == 0)
     {
-      free ((char *) multilib_os_dir);
+      free (CONST_CAST (char *, multilib_os_dir));
       multilib_os_dir = NULL;
     }
   else if (multilib_dir != NULL && multilib_os_dir == NULL)
       multilib_os_dir = NULL;
     }
   else if (multilib_dir != NULL && multilib_os_dir == NULL)
@@ -7333,7 +7592,7 @@ print_multilib_info (void)
            invalid_select:
              fatal ("multilib select '%s' is invalid", multilib_select);
            }
            invalid_select:
              fatal ("multilib select '%s' is invalid", multilib_select);
            }
-         
+
          ++p;
        }
 
          ++p;
        }
 
@@ -7556,6 +7815,44 @@ print_multilib_info (void)
     }
 }
 \f
     }
 }
 \f
+/* getenv built-in spec function.
+
+   Returns the value of the environment variable given by its first
+   argument, concatenated with the second argument.  If the
+   environment variable is not defined, a fatal error is issued.  */
+
+static const char *
+getenv_spec_function (int argc, const char **argv)
+{
+  char *value;
+  char *result;
+  char *ptr;
+  size_t len;
+
+  if (argc != 2)
+    return NULL;
+
+  value = getenv (argv[0]);
+  if (!value)
+    fatal ("environment variable \"%s\" not defined", argv[0]);
+
+  /* We have to escape every character of the environment variable so
+     they are not interpreted as active spec characters.  A
+     particularly painful case is when we are reading a variable
+     holding a windows path complete with \ separators.  */
+  len = strlen (value) * 2 + strlen (argv[1]) + 1;
+  result = XNEWVAR (char, len);
+  for (ptr = result; *value; ptr += 2)
+    {
+      ptr[0] = '\\';
+      ptr[1] = *value++;
+    }
+  
+  strcpy (ptr, argv[1]);
+  
+  return result;
+}
+
 /* if-exists built-in spec function.
 
    Checks to see if the file specified by the absolute pathname in
 /* if-exists built-in spec function.
 
    Checks to see if the file specified by the absolute pathname in
@@ -7604,7 +7901,7 @@ replace_outfile_spec_function (int argc, const char **argv)
   /* Must have exactly two arguments.  */
   if (argc != 2)
     abort ();
   /* Must have exactly two arguments.  */
   if (argc != 2)
     abort ();
-  
+
   for (i = 0; i < n_infiles; i++)
     {
       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
   for (i = 0; i < n_infiles; i++)
     {
       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
@@ -7613,7 +7910,7 @@ replace_outfile_spec_function (int argc, const char **argv)
   return NULL;
 }
 
   return NULL;
 }
 
-/* Given two version numbers, compares the two numbers.  
+/* Given two version numbers, compares the two numbers.
    A version number must match the regular expression
    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
 */
    A version number must match the regular expression
    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
 */
@@ -7622,7 +7919,7 @@ compare_version_strings (const char *v1, const char *v2)
 {
   int rresult;
   regex_t r;
 {
   int rresult;
   regex_t r;
-  
+
   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
               REG_EXTENDED | REG_NOSUB) != 0)
     abort ();
   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
               REG_EXTENDED | REG_NOSUB) != 0)
     abort ();
@@ -7651,7 +7948,7 @@ compare_version_strings (const char *v1, const char *v2)
    and nothing if it doesn't.
 
    The supported <comparison-op> values are:
    and nothing if it doesn't.
 
    The supported <comparison-op> values are:
-   
+
    >=  true if switch is a later (or same) version than arg1
    !>  opposite of >=
    <   true if switch is an earlier version than arg1
    >=  true if switch is a later (or same) version than arg1
    !>  opposite of >=
    <   true if switch is an earlier version than arg1
@@ -7676,13 +7973,13 @@ version_compare_spec_function (int argc, const char **argv)
   bool result;
 
   if (argc < 3)
   bool result;
 
   if (argc < 3)
-    abort ();
+    fatal ("too few arguments to %%:version-compare");
   if (argv[0][0] == '\0')
     abort ();
   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
     nargs = 2;
   if (argc != nargs + 3)
   if (argv[0][0] == '\0')
     abort ();
   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
     nargs = 2;
   if (argc != nargs + 3)
-    abort ();
+    fatal ("too many arguments to %%:version-compare");
 
   switch_len = strlen (argv[nargs + 1]);
   for (i = 0; i < n_switches; i++)
 
   switch_len = strlen (argv[nargs + 1]);
   for (i = 0; i < n_switches; i++)
@@ -7721,12 +8018,44 @@ version_compare_spec_function (int argc, const char **argv)
     case '<' << 8 | '>':
       result = comp1 < 0 || comp2 >= 0;
       break;
     case '<' << 8 | '>':
       result = comp1 < 0 || comp2 >= 0;
       break;
-      
+
     default:
     default:
-      abort ();
+      fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
     }
   if (! result)
     return NULL;
 
   return argv[nargs + 2];
 }
     }
   if (! result)
     return NULL;
 
   return argv[nargs + 2];
 }
+
+/* %:include builtin spec function.  This differs from %include in that it
+   can be nested inside a spec, and thus be conditionalized.  It takes
+   one argument, the filename, and looks for it in the startfile path.
+   The result is always NULL, i.e. an empty expansion.  */
+
+static const char *
+include_spec_function (int argc, const char **argv)
+{
+  char *file;
+
+  if (argc != 1)
+    abort ();
+
+  file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
+  read_specs (file ? file : argv[0], FALSE);
+
+  return NULL;
+}
+
+/* %:print-asm-header spec function.  Print a banner to say that the
+   following output is from the assembler.  */
+
+static const char *
+print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
+                               const char **argv ATTRIBUTE_UNUSED)
+{
+  printf (_("Assembler options\n=================\n\n"));
+  printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
+  fflush (stdout);
+  return NULL;
+}