[libc++] Make check_assertion.h use setjmp/longjmp instead of fork

[john.brawn]

Summary

Currently check_assertion.h checks an assertion by forking and checking the exit code of the child process, but this means such tests don't work on targets where fork doesn't exist (e.g. bare metal targets).

Instead call setjmp just before we call the function we want to test, then longjmp out of __libcpp_assertion_handler with a return value indicating whether the assert happened as expected.

[ldionne]

This looks really interesting! However, doesn't that mean that we can't assert that the process terminates if a certain condition is met?

libcxx/test/support/check_assertion.h

148

162

Here and elsewhere.

[john.brawn]

In D124255#3470538, @ldionne wrote:

This looks really interesting! However, doesn't that mean that we can't assert that the process terminates if a certain condition is met?

I'll also adjust this to use atexit to catch that kind of thing as well (and not doing this is why test_check_assertion.pass.cpp fails).

The failure in debug.erase.iter_iter.pass.cpp is a bit more complicated. At the point the assertion happens the list is in an inconsistent state, so when it's later destroyed we get a segmentation fault (this wasn't a fault previously as exiting the child process through __libcpp_assertion_handler meant we bypassed the destruction of the list). I think this can be fixed by copying the closure f after the setjmp, so the longjmp will bypass its destruction, but getting it right is a bit fiddly.

libcxx/test/support/check_assertion.h

148

Will do.

162

Will do.

[john.brawn]

After doing some more experimentation I don't think it's possible to get this to work in all cases. If we make a copy of the closure then any containers in it will be copied, but copies of iterators will still point to the container outside of the closure copy, and this causes a bunch of tests to fail.

libcxx/test/support/check_assertion.h

 #include <cassert>
 #include <cstddef>
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 #include <string_view>
 #include <utility>
 
-#include <unistd.h>
 #include <errno.h>
-#include <sys/wait.h>
+#include <setjmp.h>
 #include "test_macros.h"
 #include "test_allocator.h"
 
 #ifndef _LIBCPP_VERSION
 # error "This header may only be used for libc++ tests"
 #endif
 
 #if TEST_STD_VER < 11

 
 static constexpr AssertionInfoMatcher AnyMatcher(AssertionInfoMatcher::any_msg);
 
 inline AssertionInfoMatcher& GlobalMatcher() {
   static AssertionInfoMatcher GMatch;
   return GMatch;
 }
 
+static jmp_buf& GetJmpBuf() {
+  static jmp_buf env;
+  return env;
+}
+
 struct DeathTest {
   enum ResultKind {
-    RK_DidNotDie, RK_MatchFound, RK_MatchFailure, RK_SetupFailure, RK_Unknown
+    // This enum starts from 1 and not 0 as we want to return the ResultKind
+    // through setjmp/longjmp, which doesn't permit 0.
+    RK_DidNotDie = 1, RK_MatchFound, RK_MatchFailure, RK_Unknown
   };
 
   static const char* ResultKindToString(ResultKind RK) {
 #define CASE(K) case K: return #K
     switch (RK) {
     CASE(RK_MatchFailure);
     CASE(RK_DidNotDie);
-    CASE(RK_SetupFailure);
     CASE(RK_MatchFound);
     CASE(RK_Unknown);
     }
     return "not a result kind";
   }
 
   static bool IsValidResultKind(int val) {
     return val >= RK_DidNotDie && val <= RK_Unknown;
   }
 
   DeathTest(AssertionInfoMatcher const& Matcher) : matcher_(Matcher) {}
 
   template <class Func>
   ResultKind Run(Func&& f) {
-    int pipe_res = pipe(stdout_pipe_fd_);
-    assert(pipe_res != -1 && "failed to create pipe");
-    pipe_res = pipe(stderr_pipe_fd_);
-    assert(pipe_res != -1 && "failed to create pipe");
-    pid_t child_pid = fork();
-    assert(child_pid != -1 &&
-        "failed to fork a process to perform a death test");
-    child_pid_ = child_pid;
-    if (child_pid_ == 0) {
-      RunForChild(std::forward<Func>(f));
-      assert(false && "unreachable");
-    }
-    return RunForParent();
-  }
-
-  int getChildExitCode() const { return exit_code_; }
-  std::string const& getChildStdOut() const { return stdout_from_child_; }
-  std::string const& getChildStdErr() const { return stderr_from_child_; }
-private:
-  template <class Func>
-  TEST_NORETURN void RunForChild(Func&& f) {
-    close(GetStdOutReadFD()); // don't need to read from the pipe in the child.
-    close(GetStdErrReadFD());
-    auto DupFD = [](int DestFD, int TargetFD) {
-      int dup_result = dup2(DestFD, TargetFD);
-      if (dup_result == -1)
-        std::exit(RK_SetupFailure);
-    };
-    DupFD(GetStdOutWriteFD(), STDOUT_FILENO);
-    DupFD(GetStdErrWriteFD(), STDERR_FILENO);
-
     GlobalMatcher() = matcher_;
+    int n = setjmp(GetJmpBuf());
+    if (n == 0) {
       f();
-    std::exit(RK_DidNotDie);
-  }
-
-  static std::string ReadChildIOUntilEnd(int FD) {
-    std::string error_msg;
-    char buffer[256];
-    int num_read;
-    do {
-      while ((num_read = read(FD, buffer, 255)) > 0) {
-        buffer[num_read] = '\0';
-        error_msg += buffer;
-      }
-    } while (num_read == -1 && errno == EINTR);
-    return error_msg;
-  }
-
-  void CaptureIOFromChild() {
-    close(GetStdOutWriteFD()); // no need to write from the parent process
-    close(GetStdErrWriteFD());
-    stdout_from_child_ = ReadChildIOUntilEnd(GetStdOutReadFD());
-    stderr_from_child_ = ReadChildIOUntilEnd(GetStdErrReadFD());
-    close(GetStdOutReadFD());
-    close(GetStdErrReadFD());
-  }
-
-  ResultKind RunForParent() {
-    CaptureIOFromChild();
-
-    int status_value;
-    pid_t result = waitpid(child_pid_, &status_value, 0);
-    assert(result != -1 && "there is no child process to wait for");
-
-    if (WIFEXITED(status_value)) {
-      exit_code_ = WEXITSTATUS(status_value);
-      if (!IsValidResultKind(exit_code_))
-        return RK_Unknown;
-      return static_cast<ResultKind>(exit_code_);
+      return RK_DidNotDie;
     }
+    if (IsValidResultKind(n))
+      return (ResultKind)n;
     return RK_Unknown;
   }
 
   DeathTest(DeathTest const&) = delete;
   DeathTest& operator=(DeathTest const&) = delete;
 
-  int GetStdOutReadFD() const {
-    return stdout_pipe_fd_[0];
-  }
-
-  int GetStdOutWriteFD() const {
-    return stdout_pipe_fd_[1];
-  }
-
-  int GetStdErrReadFD() const {
-    return stderr_pipe_fd_[0];
-  }
-
-  int GetStdErrWriteFD() const {
-    return stderr_pipe_fd_[1];
-  }
 private:
   AssertionInfoMatcher matcher_;
-  pid_t child_pid_ = -1;
-  int exit_code_ = -1;
-  int stdout_pipe_fd_[2];
-  int stderr_pipe_fd_[2];
-  std::string stdout_from_child_;
-  std::string stderr_from_child_;
 };
 
 void std::__libcpp_assertion_handler(char const* file, int line, char const* /*expression*/, char const* message) {
   assert(!GlobalMatcher().empty());
   if (GlobalMatcher().Matches(file, line, message)) {
-    std::exit(DeathTest::RK_MatchFound);
+    longjmp(GetJmpBuf(), DeathTest::RK_MatchFound);
   }
-  std::exit(DeathTest::RK_MatchFailure);
+  longjmp(GetJmpBuf(), DeathTest::RK_MatchFailure);
 }
 
 template <class Func>
 inline bool ExpectDeath(const char* stmt, Func&& func, AssertionInfoMatcher Matcher) {
   DeathTest DT(Matcher);
   DeathTest::ResultKind RK = DT.Run(func);
   auto OnFailure = [&](const char* msg) {
     std::fprintf(stderr, "EXPECT_DEATH( %s ) failed! (%s)\n\n", stmt, msg);
-    if (RK != DeathTest::RK_Unknown) {
-      std::fprintf(stderr, "child exit code: %d\n", DT.getChildExitCode());
-    }
-    if (!DT.getChildStdErr().empty()) {
-      std::fprintf(stderr, "---------- standard err ----------\n%s\n", DT.getChildStdErr().c_str());
-    }
-    if (!DT.getChildStdOut().empty()) {
-      std::fprintf(stderr, "---------- standard out ----------\n%s\n", DT.getChildStdOut().c_str());
-    }
     return false;
   };
   switch (RK) {
   case DeathTest::RK_MatchFound:
     return true;
-  case DeathTest::RK_SetupFailure:
-    return OnFailure("child failed to setup test environment");
   case DeathTest::RK_Unknown:
       return OnFailure("reason unknown");
   case DeathTest::RK_DidNotDie:
       return OnFailure("child did not die");
   case DeathTest::RK_MatchFailure:
       return OnFailure("matcher failed");
   }
   assert(false && "unreachable");

libcxx/test/support/test.support/test_check_assertion.pass.cpp

 #include "check_assertion.h"
 
 template <class Func>
 inline bool TestDeathTest(const char* stmt, Func&& func, DeathTest::ResultKind ExpectResult, AssertionInfoMatcher Matcher = AnyMatcher) {
   DeathTest DT(Matcher);
   DeathTest::ResultKind RK = DT.Run(func);
   auto OnFailure = [&](std::string msg) {
     std::fprintf(stderr, "EXPECT_DEATH( %s ) failed! (%s)\n\n", stmt, msg.c_str());
-    if (!DT.getChildStdErr().empty()) {
-      std::fprintf(stderr, "---------- standard err ----------\n%s\n", DT.getChildStdErr().c_str());
-    }
-    if (!DT.getChildStdOut().empty()) {
-      std::fprintf(stderr, "---------- standard out ----------\n%s\n", DT.getChildStdOut().c_str());
-    }
     return false;
   };
   if (RK != ExpectResult)
     return OnFailure(std::string("expected result did not occur: expected ") + DeathTest::ResultKindToString(ExpectResult) + " got: " + DeathTest::ResultKindToString(RK));
   return true;
 }
 #define TEST_DEATH_TEST(RK, ...) assert((TestDeathTest(#__VA_ARGS__, [&]() { __VA_ARGS__; }, RK, AnyMatcher )))