2017-05-18 02:16:17 +08:00
|
|
|
//===- llvm/unittest/Support/CrashRecoveryTest.cpp ------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2017-05-18 02:16:17 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2020-08-26 21:21:34 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2020-09-24 21:07:13 +08:00
|
|
|
#include "llvm/Config/config.h"
|
2020-09-24 20:14:45 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2017-05-18 02:16:17 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2017-06-06 19:06:56 +08:00
|
|
|
#include "llvm/Support/CrashRecoveryContext.h"
|
2020-01-12 04:27:07 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2020-08-26 21:21:34 +08:00
|
|
|
#include "llvm/Support/Host.h"
|
2020-09-24 20:14:45 +08:00
|
|
|
#include "llvm/Support/Program.h"
|
2020-01-12 04:27:07 +08:00
|
|
|
#include "llvm/Support/Signals.h"
|
2020-08-26 21:21:34 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2017-05-18 02:16:17 +08:00
|
|
|
#include "gtest/gtest.h"
|
|
|
|
|
2018-04-29 08:45:03 +08:00
|
|
|
#ifdef _WIN32
|
2017-05-18 02:16:17 +08:00
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
|
|
#define NOGDI
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
|
2020-09-24 21:07:13 +08:00
|
|
|
#ifdef LLVM_ON_UNIX
|
|
|
|
#ifdef HAVE_SIGNAL_H
|
|
|
|
#include <signal.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2017-05-18 02:16:17 +08:00
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::sys;
|
|
|
|
|
|
|
|
static int GlobalInt = 0;
|
2017-05-25 02:11:57 +08:00
|
|
|
static void nullDeref() { *(volatile int *)0x10 = 0; }
|
2017-05-18 02:16:17 +08:00
|
|
|
static void incrementGlobal() { ++GlobalInt; }
|
|
|
|
static void llvmTrap() { LLVM_BUILTIN_TRAP; }
|
2020-01-12 04:27:07 +08:00
|
|
|
static void incrementGlobalWithParam(void *) { ++GlobalInt; }
|
2017-05-18 02:16:17 +08:00
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, Basic) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
GlobalInt = 0;
|
|
|
|
EXPECT_TRUE(CrashRecoveryContext().RunSafely(incrementGlobal));
|
|
|
|
EXPECT_EQ(1, GlobalInt);
|
|
|
|
EXPECT_FALSE(CrashRecoveryContext().RunSafely(nullDeref));
|
|
|
|
EXPECT_FALSE(CrashRecoveryContext().RunSafely(llvmTrap));
|
|
|
|
}
|
|
|
|
|
|
|
|
struct IncrementGlobalCleanup : CrashRecoveryContextCleanup {
|
|
|
|
IncrementGlobalCleanup(CrashRecoveryContext *CRC)
|
|
|
|
: CrashRecoveryContextCleanup(CRC) {}
|
2020-07-17 11:36:46 +08:00
|
|
|
void recoverResources() override { ++GlobalInt; }
|
2017-05-18 02:16:17 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static void noop() {}
|
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, Cleanup) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
GlobalInt = 0;
|
|
|
|
{
|
|
|
|
CrashRecoveryContext CRC;
|
|
|
|
CRC.registerCleanup(new IncrementGlobalCleanup(&CRC));
|
|
|
|
EXPECT_TRUE(CRC.RunSafely(noop));
|
|
|
|
} // run cleanups
|
|
|
|
EXPECT_EQ(1, GlobalInt);
|
|
|
|
|
|
|
|
GlobalInt = 0;
|
|
|
|
{
|
|
|
|
CrashRecoveryContext CRC;
|
|
|
|
CRC.registerCleanup(new IncrementGlobalCleanup(&CRC));
|
|
|
|
EXPECT_FALSE(CRC.RunSafely(nullDeref));
|
|
|
|
} // run cleanups
|
|
|
|
EXPECT_EQ(1, GlobalInt);
|
2020-01-12 04:27:07 +08:00
|
|
|
llvm::CrashRecoveryContext::Disable();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, DumpStackCleanup) {
|
|
|
|
SmallString<128> Filename;
|
|
|
|
std::error_code EC = sys::fs::createTemporaryFile("crash", "test", Filename);
|
|
|
|
EXPECT_FALSE(EC);
|
|
|
|
sys::RemoveFileOnSignal(Filename);
|
|
|
|
llvm::sys::AddSignalHandler(incrementGlobalWithParam, nullptr);
|
|
|
|
GlobalInt = 0;
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
{
|
|
|
|
CrashRecoveryContext CRC;
|
|
|
|
CRC.DumpStackAndCleanupOnFailure = true;
|
|
|
|
EXPECT_TRUE(CRC.RunSafely(noop));
|
|
|
|
}
|
|
|
|
EXPECT_TRUE(sys::fs::exists(Filename));
|
|
|
|
EXPECT_EQ(GlobalInt, 0);
|
|
|
|
{
|
|
|
|
CrashRecoveryContext CRC;
|
|
|
|
CRC.DumpStackAndCleanupOnFailure = true;
|
|
|
|
EXPECT_FALSE(CRC.RunSafely(nullDeref));
|
|
|
|
EXPECT_NE(CRC.RetCode, 0);
|
|
|
|
}
|
|
|
|
EXPECT_FALSE(sys::fs::exists(Filename));
|
|
|
|
EXPECT_EQ(GlobalInt, 1);
|
|
|
|
llvm::CrashRecoveryContext::Disable();
|
2017-05-18 02:16:17 +08:00
|
|
|
}
|
|
|
|
|
2020-08-26 21:21:34 +08:00
|
|
|
TEST(CrashRecoveryTest, LimitedStackTrace) {
|
|
|
|
std::string Res;
|
|
|
|
llvm::raw_string_ostream RawStream(Res);
|
|
|
|
PrintStackTrace(RawStream, 1);
|
|
|
|
std::string Str = RawStream.str();
|
|
|
|
// FIXME: Handle "Depth" parameter in PrintStackTrace() function
|
|
|
|
// to print stack trace upto a specified Depth.
|
2021-01-06 09:32:56 +08:00
|
|
|
if (!Triple(sys::getProcessTriple()).isOSWindows()) {
|
2020-08-26 21:21:34 +08:00
|
|
|
EXPECT_EQ(std::string::npos, Str.find("#1"));
|
2021-01-06 09:32:56 +08:00
|
|
|
}
|
2020-08-26 21:21:34 +08:00
|
|
|
}
|
|
|
|
|
2018-04-29 08:45:03 +08:00
|
|
|
#ifdef _WIN32
|
2017-05-18 02:16:17 +08:00
|
|
|
static void raiseIt() {
|
|
|
|
RaiseException(123, EXCEPTION_NONCONTINUABLE, 0, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, RaiseException) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
EXPECT_FALSE(CrashRecoveryContext().RunSafely(raiseIt));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void outputString() {
|
|
|
|
OutputDebugStringA("output for debugger\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, CallOutputDebugString) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
EXPECT_TRUE(CrashRecoveryContext().RunSafely(outputString));
|
|
|
|
}
|
|
|
|
|
2020-09-23 06:22:01 +08:00
|
|
|
TEST(CrashRecoveryTest, Abort) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
auto A = []() { abort(); };
|
|
|
|
EXPECT_FALSE(CrashRecoveryContext().RunSafely(A));
|
|
|
|
// Test a second time to ensure we reinstall the abort signal handler.
|
|
|
|
EXPECT_FALSE(CrashRecoveryContext().RunSafely(A));
|
|
|
|
}
|
2017-05-18 02:16:17 +08:00
|
|
|
#endif
|
2020-09-24 20:14:45 +08:00
|
|
|
|
|
|
|
// Specifically ensure that programs that signal() or abort() through the
|
|
|
|
// CrashRecoveryContext can re-throw again their signal, so that `not --crash`
|
|
|
|
// succeeds.
|
|
|
|
#ifdef LLVM_ON_UNIX
|
|
|
|
// See llvm/utils/unittest/UnitTestMain/TestMain.cpp
|
|
|
|
extern const char *TestMainArgv0;
|
|
|
|
|
|
|
|
// Just a reachable symbol to ease resolving of the executable's path.
|
|
|
|
static cl::opt<std::string> CrashTestStringArg1("crash-test-string-arg1");
|
|
|
|
|
|
|
|
TEST(CrashRecoveryTest, UnixCRCReturnCode) {
|
|
|
|
using namespace llvm::sys;
|
|
|
|
if (getenv("LLVM_CRC_UNIXCRCRETURNCODE")) {
|
|
|
|
llvm::CrashRecoveryContext::Enable();
|
|
|
|
CrashRecoveryContext CRC;
|
2021-01-16 00:52:58 +08:00
|
|
|
// This path runs in a subprocess that exits by signalling, so don't use
|
|
|
|
// the googletest macros to verify things as they won't report properly.
|
|
|
|
if (CRC.RunSafely(abort))
|
|
|
|
llvm_unreachable("RunSafely returned true!");
|
|
|
|
if (CRC.RetCode != 128 + SIGABRT)
|
|
|
|
llvm_unreachable("Unexpected RetCode!");
|
2020-09-24 20:14:45 +08:00
|
|
|
// re-throw signal
|
|
|
|
llvm::sys::unregisterHandlers();
|
|
|
|
raise(CRC.RetCode - 128);
|
|
|
|
llvm_unreachable("Should have exited already!");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Executable =
|
|
|
|
sys::fs::getMainExecutable(TestMainArgv0, &CrashTestStringArg1);
|
|
|
|
StringRef argv[] = {
|
|
|
|
Executable, "--gtest_filter=CrashRecoveryTest.UnixCRCReturnCode"};
|
|
|
|
|
|
|
|
// Add LLVM_CRC_UNIXCRCRETURNCODE to the environment of the child process.
|
2020-09-29 00:46:03 +08:00
|
|
|
int Res = setenv("LLVM_CRC_UNIXCRCRETURNCODE", "1", 0);
|
|
|
|
ASSERT_EQ(Res, 0);
|
2020-09-24 20:14:45 +08:00
|
|
|
|
|
|
|
std::string Error;
|
|
|
|
bool ExecutionFailed;
|
2020-09-29 00:46:03 +08:00
|
|
|
int RetCode = ExecuteAndWait(Executable, argv, {}, {}, 0, 0, &Error,
|
2020-09-24 20:14:45 +08:00
|
|
|
&ExecutionFailed);
|
|
|
|
ASSERT_EQ(-2, RetCode);
|
|
|
|
}
|
|
|
|
#endif
|