Fix codegen for throwing contracts

Author: EricWF

clang/lib/CodeGen/CGContracts.cpp

@@ -49,14 +49,27 @@ constexpr ContractViolationDetection ExceptionRaised =
     ContractViolationDetection::ExceptionRaised;
 
 namespace clang::CodeGen {
+
 enum ContractCheckpoint {
   EmittingContract,
   EmittingTryBody,
   EmittingCatchBody,
 };
+
 enum ContractEmissionStyle {
+  /// Emit the contract violation as an inline basic block immediatly following
+  /// the predicate. The basic block is not shared by other contracts.
   Inline,
+
+  /// Emit a single shared contract violation handler per-function.
+  /// This only works when exceptions are disabled, otherwise the violation
+  /// handler
+  /// may throw from the violation handler.
   SharedEnforce,
+
+  /// Emit a single shared contract violation handler per-function.
+  ///
+  /// We branch directly there skipping all cleanups.
   SharedTrap,
 };
 
@@ -216,19 +229,20 @@ void CodeGenFunction::EmitHandleContractViolationCall(
     llvm::Value *ViolationInfoGV, bool IsNoReturn) {
   auto &Ctx = getContext();
 
-  CanQualType ArgTypes[3] = {Ctx.IntTy, Ctx.IntTy, Ctx.VoidPtrTy};
+  CanQualType ArgTypes[3] = {Ctx.UnsignedIntTy, Ctx.UnsignedIntTy,
+                             Ctx.VoidPtrTy};
 
   const CGFunctionInfo &VFuncInfo =
       CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy,
                                                        ArgTypes);
+
   StringRef TargetFuncName = "__handle_contract_violation_v3";
   llvm::FunctionType *VFTy = CGM.getTypes().GetFunctionType(VFuncInfo);
   llvm::FunctionCallee VFunc = CGM.CreateRuntimeFunction(VFTy, TargetFuncName);
 
   if (IsNoReturn) {
     llvm::Value *Args[3] = {EvalSemantic, DetectionMode, ViolationInfoGV};
     EmitNoreturnRuntimeCallOrInvoke(VFunc, Args);
-
     Builder.ClearInsertionPoint();
   } else {
     CallArgList Args;
@@ -266,6 +280,9 @@ static bool StmtCanThrow(const Stmt *S) {
     // Fall through to visit the children.
   }
 
+  if (isa<CXXThrowExpr>(S))
+    return true;
+
   if (const auto *TE = dyn_cast<CXXBindTemporaryExpr>(S)) {
     // Special handling of CXXBindTemporaryExpr here as calling of Dtor of the
     // temporary is not part of `children()` as covered in the fall through.

clang/test/Contracts/Runnable/breathing-test.cpp

@@ -3,14 +3,11 @@
 
 #include "contracts.h"
 #include "contracts-runtime.h"
-#include "assert.h"
+#include "my_assert.h"
 
 using namespace std::contracts;
 
-constinit int count = 0;
-void handle_contract_violation(contract_violation const& vio) {
-  count += 1;
-}
+
 
 void test(int x) pre(x) post(x) { contract_assert(x); }
 

clang/test/Contracts/Runnable/library-compiler-interface.cpp

@@ -46,23 +46,32 @@ using namespace std::contracts;
 
 
 evaluation_semantic expected_semantic;
+detection_mode expected_mode = detection_mode::predicate_false;
 std::source_location expected_loc;
 int expected_line_offset = 0;
 unsigned handler_called = 0;
 
+
+
 extern "C" void __handle_contract_violation_v3(unsigned __sem, unsigned __mode, void *data) {
   using namespace std::contracts;
   ++handler_called;
   assert(__sem == static_cast<unsigned>(expected_semantic));
   evaluation_semantic sem = static_cast<evaluation_semantic>(__sem);
   assert(__mode == static_cast<unsigned>(detection_mode::predicate_false) ||
          __mode == static_cast<unsigned>(detection_mode::evaluation_exception));
+  assert(__mode == static_cast<unsigned>(expected_mode));
   detection_mode mode = static_cast<detection_mode>(__mode);
   BuiltinContractStruct *cs = (BuiltinContractStruct*)data;
   void* SourceLoc = reinterpret_cast<char*>(cs) + __builtin_offsetof(BuiltinContractStruct, file);
   std::source_location loc = std::source_location::__create_from_pointer(SourceLoc);
   assert(expected_loc.file_name());
   assert(location_equals(loc, expected_loc, expected_line_offset));
+  _ContractViolationImpl impl{.kind = cs->contract_kind,
+
+                              .semantic = sem,
+                              .mode = mode,
+                              .comment = cs->comment};
   if (sem == evaluation_semantic::enforce && expected_semantic == evaluation_semantic::enforce) {
     exit(0);
   }

libcxx/test/std/contracts/member_function_tests.pass.cpp

@@ -1,231 +1,8 @@
 // ADDITIONAL_COMPILE_FLAGS: -std=c++26 -Xclang -fcontracts -fcontract-evaluation-semantic=enforce
+//    -fcontract-group-evaluation-semantic=observe=observe,enforce=enforce
 
 #include "nttp_string.h"
-#include <map>
-#include <string>
-#include <cassert>
-#include <tuple>
-#include <vector>
-#include <exception>
-#include <format>
-#include <functional>
-#include <iostream>
-
-#include "test_macros.h"
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused"
-#pragma GCC diagnostic ignored "-Wunused-template"
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
-#define STR2(x) #x
-#define STR(x) STR2(x)
-#define CONCAT1(x, y) x##y
-#define CONCAT(x, y) CONCAT1(x, y)
-
-#define REGISTER_TEST(test) static ::TestRegistrar ANON_VAR(test) = []()
-
-#define ANON_VAR(id) CONCAT(anon_var_, CONCAT(id, __LINE__))
-
-#define COUNTERS_EQ(list, ...) assert(eq(list, {__VA_ARGS__}))
-
-std::map<std::string, int>& GetCounterStore() {
-  static std::map<std::string, int> CounterStore;
-  return CounterStore;
-}
-
-template <TStr Key>
-auto& KV = GetCounterStore()[Key.str()];
-
-inline bool count(bool value) {
-  KV<"AssertCounter"> += 1;
-  return value;
-}
-
-template <class T, size_t... N>
-auto array_to_tuple_impl(const T* arr, std::index_sequence<N...>) {
-  return std::tuple{arr[N]...};
-}
-
-template <class T, size_t N>
-auto array_to_tuple(T (&arr)[N]) {
-  return array_to_tuple_impl(arr, std::make_index_sequence<N>{});
-}
-
-template <class T, size_t N>
-auto array_to_tuple(const std::array<T, N>& arr) {
-  return array_to_tuple_impl(arr.data(), std::make_index_sequence<N>{});
-}
-template <class... Args>
-struct first_type;
-
-template <class T, class... Args>
-struct first_type<T, Args...> {
-  using type = T;
-  static_assert((std::is_same_v<T, Args> && ...));
-};
-template <class T>
-struct first_type<T> {
-  using type = T;
-};
-template <class... Args>
-using first_type_t = typename first_type<Args...>::type;
-
-template <class... Args>
-std::vector<first_type_t<Args...>> tuple_to_vector(std::tuple<Args...> const& tuple) {
-  return std::apply(
-      [](auto... values) {
-        std::vector<first_type_t<Args...>> result;
-        (result.push_back(values), ...);
-        return result;
-      },
-      tuple);
-}
-
-template <size_t N, class T>
-auto initlist_to_tuple(std::initializer_list<T> il) {
-  assert(il.size() == N);
-  std::array<T, N> arr = {};
-  std::copy(il.begin(), il.end(), arr.begin());
-  return array_to_tuple(arr);
-}
-
-template <class T>
-std::string vector_to_str(std::vector<T> const& V) {
-  std::string tmp = "[";
-  bool first      = true;
-  for (auto vv : V) {
-    if (!first) {
-      tmp += ", ";
-    }
-    first = false;
-    tmp += std::to_string(vv);
-  }
-  return tmp + "]";
-}
-
-template <class... Args>
-inline bool eq(std::tuple<Args...>& list, std::initializer_list<int> il) {
-  auto tup2           = initlist_to_tuple<sizeof...(Args)>(il);
-  decltype(tup2) tup3 = list;
-  bool result         = (list == tup2);
-  if (!result) {
-    std::string expect_str = vector_to_str(tuple_to_vector(tup2));
-    std::string actual_str = vector_to_str(tuple_to_vector(tup3));
-
-    std::cout << "Expected: " << expect_str << "\n";
-    std::cout << "Actual:   " << actual_str << "\n";
-    std::cout << std::endl;
-  }
-  return result;
-}
-
-template <class... Args>
-inline void reset(std::tuple<Args&...> const& list) {
-  int values[sizeof...(Args)] = {};
-  list                        = array_to_tuple(values);
-}
-
-struct RegisteredTest {
-  template <class Func>
-  RegisteredTest(Func xtest) {
-    Test = xtest;
-  }
-
-  void operator()() {
-    assert(!executed);
-    Test();
-    executed = true;
-  }
-
-  RegisteredTest(RegisteredTest const&) = delete;
-  RegisteredTest(RegisteredTest&&)      = delete;
-  ~RegisteredTest() { assert(executed); }
-
-  std::function<void()> Test;
-  bool executed = false;
-};
-
-struct TestRegistrar {
-  static std::vector<RegisteredTest*>& GetTests() {
-    static std::vector<RegisteredTest*> TestRegistrars;
-    return TestRegistrars;
-  }
-
-  static void RunTests() {
-    std::cout << "Running " << GetTests().size() << " tests\n";
-    assert(GetTests().size() > 0);
-    for (auto* Reg : GetTests()) {
-      (*Reg)();
-    }
-  }
-
-  template <class Func>
-  TestRegistrar(Func&& f) {
-    test = new RegisteredTest(std::forward<Func>(f));
-    GetTests().push_back(test);
-  }
-
-  TestRegistrar(TestRegistrar const&) = delete;
-
-  ~TestRegistrar() { assert(test->executed); }
-
-  RegisteredTest* test = nullptr;
-};
-
-struct CounterStoreT {
-  decltype(auto) get() { return GetCounterStore(); }
-
-  decltype(auto) operator[](std::string_view key) { return get()[std::string(key)]; }
-
-  decltype(auto) at(std::string_view key) { return get().at(std::string(key)); }
-
-  std::map<std::string, int>* operator->() { return &get(); }
-};
-constinit CounterStoreT CounterStore;
-
-template <auto, class T>
-using AsType = T;
-
-template <TStr Key>
-auto Counter = std::ref(CounterStore[Key.str()]);
-
-template <TStr... Key>
-auto CounterGroup = std::tuple<AsType<Key, int&>...>{GetCounterStore()[Key.str()]...};
-
-struct AliveCounter {
-  explicit AliveCounter(const char* key) : Counter(&CounterStore[key]) {
-    assert(Counter && *Counter >= 0);
-    *Counter += 1;
-  }
-
-  AliveCounter(nullptr_t) = delete;
-  AliveCounter(void*)     = delete;
-
-  constexpr AliveCounter(int* dest) : Counter(dest) {
-    assert(Counter && *Counter >= 0);
-    *Counter += 1;
-  }
-
-  constexpr AliveCounter(AliveCounter const& RHS) : Counter(RHS.Counter) {
-    assert(Counter && *Counter >= 0);
-    *Counter += 1;
-  }
-
-  ~AliveCounter() {
-    assert(*Counter >= 1);
-    *Counter -= 1;
-  }
-
-  int* Counter;
-};
-
-template <TStr Key>
-struct CAliveCounter : private AliveCounter {
-  CAliveCounter() : AliveCounter(&KV<Key>) {}
-  CAliveCounter(CAliveCounter const& RHS) : AliveCounter(RHS) {}
-
-  ~CAliveCounter() = default;
-};
+#include "contracts_test.h"
 
 namespace fn_template_test {
 template <class T>
@@ -421,6 +198,21 @@ REGISTER_TEST(order_test) {
 
 } // namespace order_test
 
+namespace exception_handling {
+
+void foo(int x) {
+  try {
+    contract_assert [[clang::contract_group("observe")]] ((true) ? throw 42 : true);
+
+  } catch (...) {
+    assert(false);
+  }
+}
+
+REGISTER_TEST(test_ex_handling) { foo(0); };
+
+} // namespace exception_handling
+
 #define ASSERT_CEQ(key, value) assert(GetCounterStore().at(STR(KEY)) == value)
 #define massert(...) assert((__VA_ARGS__))
 int main() { TestRegistrar::RunTests(); }