* Make-lang.in (CXX_EXTRA_HEADERS): Remove.

        (c++ language support bits for libgcc): Remove.
        (c++.clean): Remove cplib2.txt cleanup.
        * config-lang.in (headers, lib2funcs): Remove.

        * exception.cc, new.cc, new1.cc, new2.cc: Remove files.
        * tinfo.cc, tinfo.h, tinfo2.cc, vec.cc: Remove files.
        * inc/cxxabi.h, inc/exception, inc/new: Remove files.
        * inc/new.h, inc/typeinfo: Remove files.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@36816 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 0 insertions, 403 deletions

diff --git a/gcc/cp/exception.cc b/gcc/cp/exception.cc
deleted file mode 100644
index 886915c823b..00000000000
--- a/gcc/cp/exception.cc
+++ /dev/null
@@ -1,403 +0,0 @@
-// Functions for Exception Support for -*- C++ -*-
-// Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation
-
-// This file is part of GNU CC.
-
-// GNU CC 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 version.
-
-// GNU CC is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or 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
-// along with GNU CC; see the file COPYING.  If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330,
-// Boston, MA 02111-1307, USA. 
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction.  Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License.  This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
-
-#pragma implementation "exception"
-
-#include "typeinfo"
-#include "exception"
-#include <stddef.h>
-#include "gansidecl.h" /* Needed to support macros used in eh-common.h. */
-#include "eh-common.h"
-
-/* Define terminate, unexpected, set_terminate, set_unexpected as
-   well as the default terminate func and default unexpected func.  */
-
-extern std::terminate_handler __terminate_func __attribute__((__noreturn__));
-using std::terminate;
-
-void
-std::terminate ()
-{
-  __terminate_func ();
-}
-
-void
-__default_unexpected ()
-{
-  terminate ();
-}
-
-static std::unexpected_handler __unexpected_func __attribute__((__noreturn__))
-  = __default_unexpected;
-
-std::terminate_handler
-std::set_terminate (std::terminate_handler func)
-{
-  std::terminate_handler old = __terminate_func;
-
-  __terminate_func = func;
-  return old;
-}
-
-std::unexpected_handler
-std::set_unexpected (std::unexpected_handler func)
-{
-  std::unexpected_handler old = __unexpected_func;
-
-  __unexpected_func = func;
-  return old;
-}
-
-void
-std::unexpected ()
-{
-  __unexpected_func ();
-}
-
-/* The type of a function called to clean up an exception object.
-   (These will be destructors.)  Under the old ABI, these take a
-   second argument (the `in-charge' argument), that indicates whether
-   or not do delete the object, and whether or not to destroy virtual
-   bases.  Under the new ABI, there is no second argument.  */
-#if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
-typedef void (*cleanup_fn)(void *, int);
-/* The `2' is the value for the in-charge parameter that indicates
-   that virtual bases should be destroyed.  */
-#define CALL_CLEANUP(FN, THIS) FN (THIS, 2)
-#else
-typedef void (*cleanup_fn)(void *);
-#define CALL_CLEANUP(FN, THIS) FN (THIS)
-#endif
-
-/* C++-specific state about the current exception.
-   This must match init_exception_processing().
-
-   Note that handlers and caught are not redundant; when rethrown, an
-   exception can have multiple active handlers and still be considered
-   uncaught.  */
-
-struct cp_eh_info
-{
-  __eh_info eh_info;
-  void *value;
-  void *type;
-  cleanup_fn cleanup;
-  bool caught;
-  cp_eh_info *next;
-  long handlers;
-  void *original_value;
-};
-
-/* Language-specific EH info pointer, defined in libgcc2. */
-
-extern "C" cp_eh_info **__get_eh_info (); 	// actually void **
-
-/* Exception allocate and free, defined in libgcc2. */
-extern "C" void *__eh_alloc(size_t);
-extern "C" void __eh_free(void *);
-
-/* Is P the type_info node for a pointer of some kind?  */
-
-extern bool __is_pointer (void *);
-
-
-/* OLD Compiler hook to return a pointer to the info for the current exception.
-   Used by get_eh_info ().  This fudges the actualy returned value to
-   point to the beginning of what USE to be the cp_eh_info structure.
-   THis is so that old code that dereferences this pointer will find
-   things where it expects it to be.*/
-extern "C" void *
-__cp_exception_info (void)
-{
-  return &((*__get_eh_info ())->value);
-}
-
-#define CP_EH_INFO ((cp_eh_info *) *__get_eh_info ())
-
-/* Old Compiler hook to return a pointer to the info for the current exception.
-   Used by get_eh_info ().  */
-
-extern "C" cp_eh_info *
-__cp_eh_info (void)
-{
-  cp_eh_info *p = CP_EH_INFO;
-  return p;
-}
-
-/* Compiler hook to return a pointer to the info for the current exception,
-   Set the caught bit, and increment the number of handlers that are
-   looking at this exception. This makes handlers smaller. */
-
-extern "C" cp_eh_info *
-__start_cp_handler (void)
-{
-  cp_eh_info *p = CP_EH_INFO;
-  p->caught = 1;
-  p->handlers++;
-  return p;
-}
-
-extern "C" int __throw_type_match_rtti_2 (const void *, const void *,
-					 void *, void **);
-
-extern "C" void *
-__cplus_type_matcher (__eh_info *info_, void *match_info,
-		      exception_descriptor *exception_table)
-{
-  cp_eh_info *info = (cp_eh_info *)info_;
-
-  /* No exception table implies the old style mechanism, so don't check. */
-  if (exception_table != NULL 
-      && exception_table->lang.language != EH_LANG_C_plus_plus)
-    return NULL;
-
-  if (match_info == CATCH_ALL_TYPE)
-    return (void *)1;
-
-  /* we don't worry about version info yet, there is only one version! */
-  
-  void *match_type = match_info;
-  
-#if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
-  match_type  = ((void *(*)())match_type) ();
-#endif
-
-  if (__throw_type_match_rtti_2 (match_type, info->type,
-				 info->original_value, &info->value))
-    // Arbitrary non-null pointer.
-    return (void *)1;
-  else
-    return NULL;
-}
-
-/* Compiler hook to push a new exception onto the stack.
-   Used by expand_throw().  */
-
-extern "C" void
-__cp_push_exception (void *value, void *type, cleanup_fn cleanup)
-{
-  cp_eh_info *p = (cp_eh_info *) __eh_alloc (sizeof (cp_eh_info));
-
-  p->value = value;
-  p->type = type;
-  p->cleanup = cleanup;
-  p->handlers = 0;
-  p->caught = false;
-  p->original_value = value;
-
-  p->eh_info.match_function = __cplus_type_matcher;
-  p->eh_info.language = EH_LANG_C_plus_plus;
-  p->eh_info.version = 1;
-
-  cp_eh_info **q = __get_eh_info ();
-
-  p->next = *q;
-  *q = p;
-}
-
-/* Compiler hook to pop an exception that has been finalized.  Used by
-   push_eh_cleanup().  P is the info for the exception caught by the
-   current catch block.  */
-
-extern "C" void
-__cp_pop_exception (cp_eh_info *p)
-{
-  cp_eh_info **stack = __get_eh_info ();
-  cp_eh_info **q = stack;
-
-  --p->handlers;
-
-  /* Do nothing if our exception is being rethrown (i.e. if the active
-     exception is our exception and it is uncaught).  */
-  if (p == *q && !p->caught)
-    return;
-
-  /* Don't really pop if there are still active handlers for our exception;
-     rather, push it down past any uncaught exceptions.  */
-  if (p->handlers != 0)
-    {
-      if (p == *q && p->next && !p->next->caught)
-	{
-	  q = &(p->next);
-	  while (1)
-	    {
-	      if (*q == 0 || (*q)->caught)
-		break;
-
-	      q = &((*q)->next);
-	    }
-	  *stack = p->next;
-	  p->next = *q;
-	  *q = p;
-	}
-      return;
-    }
-
-  for (; *q; q = &((*q)->next))
-    if (*q == p)
-      break;
-
-  if (! *q)
-    terminate ();
-
-  *q = p->next;
-
-  if (p->cleanup)
-    // value may have been adjusted.
-    CALL_CLEANUP (p->cleanup, p->original_value);
-
-  if (! __is_pointer (p->type))
-    __eh_free (p->original_value);  // value may have been adjusted.
-
-  __eh_free (p);
-}
-
-/* We're doing a rethrow.  Find the currently handled exception, mark it
-   uncaught, and move it to the top of the EH stack.  */
-
-extern "C" void
-__uncatch_exception (void)
-{
-  cp_eh_info **stack = __get_eh_info ();
-  cp_eh_info **q = stack;
-  cp_eh_info *p;
-
-  while (1)
-    {
-      p = *q;
-
-      if (p == 0)
-	terminate ();
-      if (p->caught)
-	break;
-
-      q = &(p->next);
-    }
-
-  if (q != stack)
-    {
-      *q = p->next;
-      p->next = *stack;
-      *stack = p;
-    }
-
-  p->caught = false;
-}
-
-/* As per [except.unexpected]:
-   If an exception is thrown, we check it against the spec.  If it doesn't
-   match, we call unexpected ().  If unexpected () throws, we check that
-   exception against the spec.  If it doesn't match, if the spec allows
-   bad_exception we throw that; otherwise we call terminate ().
-
-   The compiler treats an exception spec as a try block with a generic
-   handler that just calls this function with a list of the allowed
-   exception types, so we have an active exception that can be rethrown.
-
-   This function does not return.  */   
-
-extern "C" void
-__check_eh_spec (int n, const void **spec)
-{
-  cp_eh_info *p = CP_EH_INFO;
-  void *d;
-
-  for (int i = 0; i < n; ++i)
-    {
-      if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
-	throw;
-    }
-
-  try
-    {
-      std::unexpected ();
-    }
-  catch (...)
-    {
-      // __exception_info is an artificial var pushed into each catch block.
-      if (p != __exception_info)
-	{
-	  p = __exception_info;
-	  for (int i = 0; i < n; ++i)
-	    {
-	      if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
-		throw;
-	    }
-	}
-
-      const std::type_info &bad_exc = typeid (std::bad_exception);
-      for (int i = 0; i < n; ++i)
-	{
-	  if (__throw_type_match_rtti_2 (spec[i], &bad_exc, p->value, &d))
-	    throw std::bad_exception ();
-	}
-
-      terminate ();
-    }
-}
-
-/* Special case of the above for throw() specs.  */
-
-extern "C" void
-__check_null_eh_spec (void)
-{
-  __check_eh_spec (0, 0);
-}
-
-// Helpers for rtti. Although these don't return, we give them return types so
-// that the type system is not broken.
-
-extern "C" void *
-__throw_bad_cast ()
-{
-  throw std::bad_cast ();
-  return 0;
-}
-
-extern "C" std::type_info const &
-__throw_bad_typeid ()
-{
-  throw std::bad_typeid ();
-  return typeid (void);
-}
-
-/* Has the current exception been caught?  */
-
-bool
-std::uncaught_exception ()
-{
-  cp_eh_info *p = CP_EH_INFO;
-  return p && ! p->caught;
-}
-
-const char * std::exception::
-what () const
-{
-  return typeid (*this).name ();
-}