Add tests for C++ exception types that use virtual base classes

tests/toolchain/eh_throw_tests.cc

 /*
  * Copyright (c) 2013 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <setjmp.h>
 #include <stdio.h>
 
@@ skipping 310 matching lines @@
       // where the return address has been overwritten with
       // longjmp()'s return address, so we return here.
       assert(false);
     }
   } catch (...) {
     assert(false);
   }
 }
 
 
+void allowed_exception_spec() throw(MyException) {
+  throw MyException(600);
+}
+
+// Test a case in which an exception propagates through an exception
+// spec which allows the exception type.
+void test_exception_spec_allowed() {
+  bool caught = false;
+  try {
+    allowed_exception_spec();
+  } catch (MyException &exc) {
+    assert(exc.value == 600);
+    caught = true;
+  }
+  assert(caught);
+}
+
+
+class VirtualBase {
+ public:
+  VirtualBase() : value(321) {}
+  int value;
+};
+
+class VirtualDerived : virtual public VirtualBase {};
+
+void allowed_exception_spec_virtual_base() throw(VirtualBase) {
+  throw VirtualDerived();
+}
+
+// Test that exception types with virtual base classes work when the
+// base class appears in an exception spec.
+//
+// In this case, the C++ runtime library must dereference the
+// exception's vtable to find the offset of VirtualBase within
+// VirtualDerived.  That is not the case with non-virtual bases, for
+// which the std::type_info data is enough to adjust the pointer to
+// the exception without dereferencing it.
+void test_exception_spec_allowed_with_virtual_base() {
+  bool caught = false;
+  try {
+    allowed_exception_spec_virtual_base();
+  } catch (VirtualBase &exc) {
+    assert(exc.value == 321);
+    caught = true;
+  }
+  assert(caught);
+}
+
+
 class RethrowExc {};
 
 bool g_dtor_called;
 
 void rethrow_unexpected_handler() {
   // func_with_exception_spec()'s destructors should be run before the
   // exception spec (a "filter" clause in LLVM) is checked and we are
   // called.
   //
   // This means that the std::set_unexpected() handler should be
@@ skipping 11 matching lines @@
 void func_with_exception_spec() throw(RethrowExc) {
   Dtor dtor(&g_dtor_called);
   throw MyException(100);
 }
 
 // Test that exception specs work.  Test that if an exception doesn't
 // match the exception spec of a function, the current
 // std::set_unexpected() handler is called.  The handler is allowed to
 // throw a new exception that matches the exception spec -- we test
 // this case to avoid aborting execution.
-void test_exception_spec() {
+void test_exception_spec_calls_handler() {
   g_dtor_called = false;
   std::unexpected_handler old_unexpected_handler =
       std::set_unexpected(rethrow_unexpected_handler);
   bool caught = false;
   try {
     func_with_exception_spec();
   } catch (RethrowExc &) {
     caught = true;
   }
   assert(caught);
   // Clean up.
   std::set_unexpected(old_unexpected_handler);
 }
 
 
+void unexpected_handler_throwing_virtual_base() {
+  throw VirtualDerived();
+}
+
+void disallowed_exception_spec_virtual_base() throw(VirtualBase) {
+  throw MyException(0);
+}
+
+// Test that if a std::set_unexpected() handler throws an exception
+// with a virtual base class, this new exception is checked against
+// the original exception spec correctly.
+void test_exception_spec_handler_throws_virtual_base() {
+  std::unexpected_handler old_unexpected_handler =
+      std::set_unexpected(unexpected_handler_throwing_virtual_base);
+  bool caught = false;
+  try {
+    disallowed_exception_spec_virtual_base();
+  } catch (VirtualBase &exc) {
+    assert(exc.value == 321);
+    caught = true;
+  }
+  assert(caught);
+  // Clean up.
+  std::set_unexpected(old_unexpected_handler);
+}
+
+
 void rethrowing_unexpected_handler() {
   try {
     throw;
   } catch (MyException &exc) {
     assert(exc.value == 100);
   }
   throw RethrowExc();
 }
 
 // Test that the "current exception" inside the std::set_unexpected()
@@ skipping 181 matching lines @@
   RUN_TEST(test_catch_all());
   RUN_TEST(test_nested_try_blocks());
   RUN_TEST(test_throw_in_catch_block());
   RUN_TEST(test_dtor());
   RUN_TEST(test_rethrow());
   RUN_TEST(test_stack_of_exceptions());
   RUN_TEST(test_multiple_inheritance_exception());
   RUN_TEST(test_multiple_inheritance_exception_ptr());
   RUN_TEST(test_throw_catch_nested_in_dtor());
   RUN_TEST(test_setjmp_called_via_invoke());
-  RUN_TEST(test_exception_spec());
+  RUN_TEST(test_exception_spec_allowed());
+  RUN_TEST(test_exception_spec_allowed_with_virtual_base());
+  RUN_TEST(test_exception_spec_calls_handler());
+  RUN_TEST(test_exception_spec_handler_throws_virtual_base());
   RUN_TEST(test_exception_spec_rethrow_inside_unexpected_handler());
   RUN_TEST(test_exception_spec_convert_to_bad_exception());
 #if SUPPORTS_CXX11
   RUN_TEST(test_dependent_exception());
   RUN_TEST(test_dependent_exception_and_dtor());
   RUN_TEST(test_dependent_exception_and_exception_spec());
 #endif
   // This leaves behind an active exception because of its use of
   // longjmp() to exit from a std::set_terminate() handler, so put it
   // last, just in case that accidentally affects other tests.
   RUN_TEST(test_exception_spec_bad_throw_from_unexpected_handler());
 
   // Indicate success.
   return 55;
 }