This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[rfc] fix libstdc++/10606


The following implements the proposal Cary Coutant gave to
the c++ abi devel list.

Does everyone agree that the test case attached is correct?
Are there other cases that need to be considered?

Library folk: Is CXXABI_1.4 the correct version to give to
this symbol?



r~


gcc/cp/
	* except.c (do_get_exception_ptr): New.
	(expand_start_catch_block): Use it to construct the catch
	object before considering the exception to be handled.

gcc/testsuite/
	* g++.dg/eh/uncaught1.C: New.

libstdc++-v3/
	* config/linker-map.gnu (CXXABI_1.4): New.
	* libsupc++/eh_catch.cc (__cxa_get_exception_ptr): New.
	(__cxa_end_catch): Move increment of uncaughtExceptions ...
	* libsupc++/eh_throw.cc (__cxa_rethrow): ... here.
	* libsupc++/unwind-cxx.h (__cxa_get_exception_ptr): Declare.

Index: gcc/cp/except.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/except.c,v
retrieving revision 1.178
diff -u -p -r1.178 except.c
--- gcc/cp/except.c	8 Dec 2004 08:35:41 -0000	1.178
+++ gcc/cp/except.c	28 Dec 2004 08:07:58 -0000
@@ -153,6 +153,26 @@ build_exc_ptr (void)
   return build0 (EXC_PTR_EXPR, ptr_type_node);
 }
 
+/* Build up a call to __cxa_get_exception_ptr so that we can build a
+   copy constructor for the thrown object.  */
+
+static tree
+do_get_exception_ptr (void)
+{
+  tree fn;
+
+  fn = get_identifier ("__cxa_get_exception_ptr");
+  if (!get_global_value_if_present (fn, &fn))
+    {
+      /* Declare void* __cxa_get_exception_ptr (void *).  */
+      tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
+      fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
+    }
+
+  return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
+					     NULL_TREE));
+}
+
 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
    exception has been handled.  */
 
@@ -378,9 +398,8 @@ initialize_handler_parm (tree decl, tree
 tree
 expand_start_catch_block (tree decl)
 {
-  tree exp = NULL_TREE;
+  tree exp;
   tree type;
-  bool is_java;
 
   if (! doing_eh (1))
     return NULL_TREE;
@@ -394,45 +413,50 @@ expand_start_catch_block (tree decl)
   else
     type = NULL_TREE;
 
-  is_java = false;
-  if (decl)
+  if (decl && decl_is_java_type (type, 1))
     {
-      tree init;
+      /* Java only passes object via pointer and doesn't require
+	 adjusting.  The java object is immediately before the
+	 generic exception header.  */
+      exp = build_exc_ptr ();
+      exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
+      exp = build2 (MINUS_EXPR, TREE_TYPE (exp), exp,
+		    TYPE_SIZE_UNIT (TREE_TYPE (exp)));
+      exp = build_indirect_ref (exp, NULL);
+      initialize_handler_parm (decl, exp);
+      return type;
+    }
+
+  /* Call __cxa_end_catch at the end of processing the exception.  */
+  push_eh_cleanup (type);
+
+  /* If there's no decl at all, then all we need to do is make sure
+     to tell the runtime that we've begun handling the exception.  */
+  if (decl == NULL)
+    finish_expr_stmt (do_begin_catch ());
 
-      if (decl_is_java_type (type, 1))
-	{
-	  /* Java only passes object via pointer and doesn't require
-	     adjusting.  The java object is immediately before the
-	     generic exception header.  */
-	  init = build_exc_ptr ();
-	  init = build1 (NOP_EXPR, build_pointer_type (type), init);
-	  init = build2 (MINUS_EXPR, TREE_TYPE (init), init,
-			 TYPE_SIZE_UNIT (TREE_TYPE (init)));
-	  init = build_indirect_ref (init, NULL);
-	  is_java = true;
-	}
-      else
-	{
-	  /* C++ requires that we call __cxa_begin_catch to get the
-	     pointer to the actual object.  */
-	  init = do_begin_catch ();
-	}
-	  
+  /* If the C++ object needs constructing, we need to do that before
+     calling __cxa_begin_catch, so that std::uncaught_exception gets
+     the right value during the copy constructor.  */
+  else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
+    {
+      exp = do_get_exception_ptr ();
+      initialize_handler_parm (decl, exp);
+      finish_expr_stmt (do_begin_catch ());
+    }
+
+  /* Otherwise the type uses a bitwise copy, and we don't have to worry
+     about the value of std::uncaught_exception and therefore can do the
+     copy with the return value of __cxa_end_catch instead.  */
+  else
+    {
+      tree init = do_begin_catch ();
       exp = create_temporary_var (ptr_type_node);
       DECL_REGISTER (exp) = 1;
       cp_finish_decl (exp, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
       finish_expr_stmt (build_modify_expr (exp, INIT_EXPR, init));
+      initialize_handler_parm (decl, exp);
     }
-  else
-    finish_expr_stmt (do_begin_catch ());
-
-  /* C++ requires that we call __cxa_end_catch at the end of
-     processing the exception.  */
-  if (! is_java)
-    push_eh_cleanup (type);
-
-  if (decl)
-    initialize_handler_parm (decl, exp);
 
   return type;
 }
Index: libstdc++-v3/config/linker-map.gnu
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/config/linker-map.gnu,v
retrieving revision 1.76
diff -u -p -r1.76 linker-map.gnu
--- libstdc++-v3/config/linker-map.gnu	8 Nov 2004 20:06:28 -0000	1.76
+++ libstdc++-v3/config/linker-map.gnu	28 Dec 2004 08:08:11 -0000
@@ -406,3 +406,9 @@ CXXABI_1.3 {
   local:
     *;
 };
+
+CXXABI_1.4 {
+
+    __cxa_get_exception_ptr;
+
+} CXXABI_1.3;
Index: libstdc++-v3/libsupc++/eh_catch.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/eh_catch.cc,v
retrieving revision 1.8
diff -u -p -r1.8 eh_catch.cc
--- libstdc++-v3/libsupc++/eh_catch.cc	3 Aug 2004 06:45:54 -0000	1.8
+++ libstdc++-v3/libsupc++/eh_catch.cc	28 Dec 2004 08:08:11 -0000
@@ -33,6 +33,15 @@
 
 using namespace __cxxabiv1;
 
+extern "C" void *
+__cxxabiv1::__cxa_get_exception_ptr(void *exc_obj_in) throw()
+{
+  _Unwind_Exception *exceptionObject
+    = reinterpret_cast <_Unwind_Exception *>(exc_obj_in);
+  __cxa_exception *header = __get_exception_header_from_ue (exceptionObject);
+
+  return header->adjustedPtr;
+}
 
 extern "C" void *
 __cxxabiv1::__cxa_begin_catch (void *exc_obj_in) throw()
@@ -107,10 +116,7 @@ __cxxabiv1::__cxa_end_catch ()
       // This exception was rethrown.  Decrement the (inverted) catch
       // count and remove it from the chain when it reaches zero.
       if (++count == 0)
-	{
-	  globals->uncaughtExceptions += 1;
-	  globals->caughtExceptions = header->nextException;
-	}
+	globals->caughtExceptions = header->nextException;
     }
   else if (--count == 0)
     {
Index: libstdc++-v3/libsupc++/eh_throw.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/eh_throw.cc,v
retrieving revision 1.8
diff -u -p -r1.8 eh_throw.cc
--- libstdc++-v3/libsupc++/eh_throw.cc	3 Aug 2004 06:45:54 -0000	1.8
+++ libstdc++-v3/libsupc++/eh_throw.cc	28 Dec 2004 08:08:11 -0000
@@ -86,6 +86,8 @@ __cxxabiv1::__cxa_rethrow ()
   __cxa_eh_globals *globals = __cxa_get_globals ();
   __cxa_exception *header = globals->caughtExceptions;
 
+  globals->uncaughtExceptions += 1;
+
   // Watch for luser rethrowing with no active exception.
   if (header)
     {
Index: libstdc++-v3/libsupc++/unwind-cxx.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/unwind-cxx.h,v
retrieving revision 1.7
diff -u -p -r1.7 unwind-cxx.h
--- libstdc++-v3/libsupc++/unwind-cxx.h	3 Aug 2004 06:45:54 -0000	1.7
+++ libstdc++-v3/libsupc++/unwind-cxx.h	28 Dec 2004 08:08:11 -0000
@@ -107,6 +107,7 @@ extern "C" void __cxa_throw (void *throw
      __attribute__((noreturn));
 
 // Used to implement exception handlers.
+extern "C" void *__cxa_get_exception_ptr (void *) throw();
 extern "C" void *__cxa_begin_catch (void *) throw();
 extern "C" void __cxa_end_catch ();
 extern "C" void __cxa_rethrow () __attribute__((noreturn));
Index: gcc/testsuite/g++.dg/eh/uncaught1.C
===================================================================
RCS file: gcc/testsuite/g++.dg/eh/uncaught1.C
diff -N gcc/testsuite/g++.dg/eh/uncaught1.C
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gcc/testsuite/g++.dg/eh/uncaught1.C	28 Dec 2004 08:10:24 -0000
@@ -0,0 +1,83 @@
+// PR libstdc++/10606
+// { dg-do run }
+
+#include <exception>
+#include <cstdlib>
+
+
+struct Check {
+  int obj1, obj2;
+  bool state;
+};
+
+static Check const data[] = {
+  { 0, 0, false },	// construct [0]
+  { 1, 0, false },	// [1] = [0]
+  { 0, 0, true  },	// destruct [0]
+  { 2, 1, true  },	// [2] = [1]
+  { 2, 2, true  },      // destruct [2]
+  { 3, 1, true  },	// [3] = [1]
+  { 3, 3, false },	// destruct [3]
+  { 1, 1, false },	// destruct [1]
+  { 9, 9, false }	// end-of-data
+};
+
+static int pos = 0;
+
+static void test(int obj1, int obj2, bool state)
+{
+  if (obj1 != data[pos].obj1) abort ();
+  if (obj2 != data[pos].obj2) abort ();
+  if (state != data[pos].state) abort ();
+  pos++;
+}
+
+
+struct S {
+  int id;
+  S ();
+  S (const S &);
+  ~S ();
+};
+
+static int next_id = 0;
+
+S::S()
+  : id (next_id++)
+{
+  test (id, id, std::uncaught_exception ());
+}
+
+S::S(const S &x)
+  : id (next_id++)
+{
+  test (id, x.id, std::uncaught_exception ());
+}
+
+S::~S()
+{
+  test (id, id, std::uncaught_exception ());
+}
+
+extern void foo (S *);
+
+int main()
+{
+  try
+    {
+      try
+	{
+	  S s0;
+	  throw s0;	// s1 is the exception object
+	}
+      catch (S s2)
+	{
+	  throw;
+	}
+    }
+  catch (S s3)
+    {
+    }
+ 
+  return 0;
+}


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]