428 changes: 428 additions & 0 deletions compiler-rt/lib/orc/error.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,428 @@
//===-------- Error.h - Enforced error checking for ORC RT ------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//

#ifndef ORC_RT_ERROR_H
#define ORC_RT_ERROR_H

#include "compiler.h"
#include "extensible_rtti.h"
#include "stl_extras.h"

#include <cassert>
#include <memory>
#include <string>
#include <type_traits>

namespace __orc_rt {

/// Base class for all errors.
class ErrorInfoBase : public RTTIExtends<ErrorInfoBase, RTTIRoot> {
public:
virtual std::string toString() const = 0;
};

/// Represents an environmental error.
class ORC_RT_NODISCARD Error {

template <typename ErrT, typename... ArgTs>
friend Error make_error(ArgTs &&...Args);

friend Error repackage_error(std::unique_ptr<ErrorInfoBase>);

template <typename ErrT> friend std::unique_ptr<ErrT> error_cast(Error &);

template <typename T> friend class Expected;

public:
/// Destroy this error. Aborts if error was not checked, or was checked but
/// not handled.
~Error() { assertIsChecked(); }

Error(const Error &) = delete;
Error &operator=(const Error &) = delete;

/// Move-construct an error. The newly constructed error is considered
/// unchecked, even if the source error had been checked. The original error
/// becomes a checked success value.
Error(Error &&Other) {
setChecked(true);
*this = std::move(Other);
}

/// Move-assign an error value. The current error must represent success, you
/// you cannot overwrite an unhandled error. The current error is then
/// considered unchecked. The source error becomes a checked success value,
/// regardless of its original state.
Error &operator=(Error &&Other) {
// Don't allow overwriting of unchecked values.
assertIsChecked();
setPtr(Other.getPtr());

// This Error is unchecked, even if the source error was checked.
setChecked(false);

// Null out Other's payload and set its checked bit.
Other.setPtr(nullptr);
Other.setChecked(true);

return *this;
}

/// Create a success value.
static Error success() { return Error(); }

/// Error values convert to true for failure values, false otherwise.
explicit operator bool() {
setChecked(getPtr() == nullptr);
return getPtr() != nullptr;
}

/// Return true if this Error contains a failure value of the given type.
template <typename ErrT> bool isA() const {
return getPtr() && getPtr()->isA<ErrT>();
}

private:
Error() = default;

Error(std::unique_ptr<ErrorInfoBase> ErrInfo) {
auto RawErrPtr = reinterpret_cast<uintptr_t>(ErrInfo.release());
assert((RawErrPtr & 0x1) == 0 && "ErrorInfo is insufficiently aligned");
ErrPtr = RawErrPtr | 0x1;
}

void assertIsChecked() {
if (ORC_RT_UNLIKELY(!isChecked() || getPtr())) {
fprintf(stderr, "Error must be checked prior to destruction.\n");
abort(); // Some sort of JIT program abort?
}
}

template <typename ErrT = ErrorInfoBase> ErrT *getPtr() const {
return reinterpret_cast<ErrT *>(ErrPtr & ~uintptr_t(1));
}

void setPtr(ErrorInfoBase *Ptr) {
ErrPtr = (reinterpret_cast<uintptr_t>(Ptr) & ~uintptr_t(1)) | (ErrPtr & 1);
}

bool isChecked() const { return ErrPtr & 0x1; }

void setChecked(bool Checked) {
ErrPtr = (reinterpret_cast<uintptr_t>(ErrPtr) & ~uintptr_t(1)) | Checked;
}

template <typename ErrT = ErrorInfoBase> std::unique_ptr<ErrT> takePayload() {
static_assert(std::is_base_of<ErrorInfoBase, ErrT>::value,
"ErrT is not an ErrorInfoBase subclass");
std::unique_ptr<ErrT> Tmp(getPtr<ErrT>());
setPtr(nullptr);
setChecked(true);
return Tmp;
}

uintptr_t ErrPtr = 0;
};

/// Construct an error of ErrT with the given arguments.
template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&...Args) {
static_assert(std::is_base_of<ErrorInfoBase, ErrT>::value,
"ErrT is not an ErrorInfoBase subclass");
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
}

/// Construct an error of ErrT using a std::unique_ptr<ErrorInfoBase>. The
/// primary use-case for this is 're-packaging' errors after inspecting them
/// using error_cast, hence the name.
inline Error repackage_error(std::unique_ptr<ErrorInfoBase> EIB) {
return Error(std::move(EIB));
}

/// If the argument is an error of type ErrT then this function unpacks it
/// and returns a std::unique_ptr<ErrT>. Otherwise returns a nullptr and
/// leaves the error untouched. Common usage looks like:
///
/// \code{.cpp}
/// if (Error E = foo()) {
/// if (auto EV1 = error_cast<ErrorType1>(E)) {
/// // use unwrapped EV1 value.
/// } else if (EV2 = error_cast<ErrorType2>(E)) {
/// // use unwrapped EV2 value.
/// } ...
/// }
/// \endcode
template <typename ErrT> std::unique_ptr<ErrT> error_cast(Error &Err) {
static_assert(std::is_base_of<ErrorInfoBase, ErrT>::value,
"ErrT is not an ErrorInfoBase subclass");
if (Err.isA<ErrT>())
return Err.takePayload<ErrT>();
return nullptr;
}

/// Helper for Errors used as out-parameters.
/// Sets the 'checked' flag on construction, resets it on destruction.
class ErrorAsOutParameter {
public:
ErrorAsOutParameter(Error *Err) : Err(Err) {
// Raise the checked bit if Err is success.
if (Err)
(void)!!*Err;
}

~ErrorAsOutParameter() {
// Clear the checked bit.
if (Err && !*Err)
*Err = Error::success();
}

private:
Error *Err;
};

template <typename T> class ORC_RT_NODISCARD Expected {

template <class OtherT> friend class Expected;

static constexpr bool IsRef = std::is_reference<T>::value;
using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
using error_type = std::unique_ptr<ErrorInfoBase>;
using storage_type = std::conditional_t<IsRef, wrap, T>;
using value_type = T;

using reference = std::remove_reference_t<T> &;
using const_reference = const std::remove_reference_t<T> &;
using pointer = std::remove_reference_t<T> *;
using const_pointer = const std::remove_reference_t<T> *;

public:
/// Create an Expected from a failure value.
Expected(Error Err) : HasError(true), Unchecked(true) {
assert(Err && "Cannot create Expected<T> from Error success value");
new (getErrorStorage()) error_type(Err.takePayload());
}

/// Create an Expected from a T value.
template <typename OtherT>
Expected(OtherT &&Val,
std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
: HasError(false), Unchecked(true) {
new (getStorage()) storage_type(std::forward<OtherT>(Val));
}

/// Move-construct an Expected<T> from an Expected<OtherT>.
Expected(Expected &&Other) { moveConstruct(std::move(Other)); }

/// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
/// must be convertible to T.
template <class OtherT>
Expected(
Expected<OtherT> &&Other,
std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
moveConstruct(std::move(Other));
}

/// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
/// isn't convertible to T.
template <class OtherT>
explicit Expected(
Expected<OtherT> &&Other,
std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
moveConstruct(std::move(Other));
}

/// Move-assign from another Expected<T>.
Expected &operator=(Expected &&Other) {
moveAssign(std::move(Other));
return *this;
}

/// Destroy an Expected<T>.
~Expected() {
assertIsChecked();
if (!HasError)
getStorage()->~storage_type();
else
getErrorStorage()->~error_type();
}

/// Returns true if this Expected value is in a success state (holding a T),
/// and false if this Expected value is in a failure state.
explicit operator bool() {
Unchecked = HasError;
return !HasError;
}

/// Returns true if this Expected value holds an Error of type error_type.
template <typename ErrT> bool isFailureOfType() const {
return HasError && (*getErrorStorage())->template isFailureOfType<ErrT>();
}

/// Take ownership of the stored error.
///
/// If this Expected value is in a success state (holding a T) then this
/// method is a no-op and returns Error::success.
///
/// If thsi Expected value is in a failure state (holding an Error) then this
/// method returns the contained error and leaves this Expected in an
/// 'empty' state from which it may be safely destructed but not otherwise
/// accessed.
Error takeError() {
Unchecked = false;
return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
}

/// Returns a pointer to the stored T value.
pointer operator->() {
assertIsChecked();
return toPointer(getStorage());
}

/// Returns a pointer to the stored T value.
const_pointer operator->() const {
assertIsChecked();
return toPointer(getStorage());
}

/// Returns a reference to the stored T value.
reference operator*() {
assertIsChecked();
return *getStorage();
}

/// Returns a reference to the stored T value.
const_reference operator*() const {
assertIsChecked();
return *getStorage();
}

private:
template <class T1>
static bool compareThisIfSameType(const T1 &a, const T1 &b) {
return &a == &b;
}

template <class T1, class T2>
static bool compareThisIfSameType(const T1 &a, const T2 &b) {
return false;
}

template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
HasError = Other.HasError;
Unchecked = true;
Other.Unchecked = false;

if (!HasError)
new (getStorage()) storage_type(std::move(*Other.getStorage()));
else
new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
}

template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
assertIsChecked();

if (compareThisIfSameType(*this, Other))
return;

this->~Expected();
new (this) Expected(std::move(Other));
}

pointer toPointer(pointer Val) { return Val; }

const_pointer toPointer(const_pointer Val) const { return Val; }

pointer toPointer(wrap *Val) { return &Val->get(); }

const_pointer toPointer(const wrap *Val) const { return &Val->get(); }

storage_type *getStorage() {
assert(!HasError && "Cannot get value when an error exists!");
return reinterpret_cast<storage_type *>(&TStorage);
}

const storage_type *getStorage() const {
assert(!HasError && "Cannot get value when an error exists!");
return reinterpret_cast<const storage_type *>(&TStorage);
}

error_type *getErrorStorage() {
assert(HasError && "Cannot get error when a value exists!");
return reinterpret_cast<error_type *>(&ErrorStorage);
}

const error_type *getErrorStorage() const {
assert(HasError && "Cannot get error when a value exists!");
return reinterpret_cast<const error_type *>(&ErrorStorage);
}

void assertIsChecked() {
if (ORC_RT_UNLIKELY(Unchecked)) {
fprintf(stderr,
"Expected<T> must be checked before access or destruction.\n");
abort();
}
}

union {
std::aligned_union_t<1, storage_type> TStorage;
std::aligned_union_t<1, error_type> ErrorStorage;
};

bool HasError : 1;
bool Unchecked : 1;
};

/// Consume an error without doing anything.
inline void consumeError(Error Err) {
if (Err)
(void)error_cast<ErrorInfoBase>(Err);
}

/// Consumes success values. It is a programmatic error to call this function
/// on a failure value.
inline void cantFail(Error Err) {
assert(!Err && "cantFail called on failure value");
consumeError(std::move(Err));
}

/// Auto-unwrap an Expected<T> value in the success state. It is a programmatic
/// error to call this function on a failure value.
template <typename T> T cantFail(Expected<T> E) {
assert(E && "cantFail called on failure value");
consumeError(E.takeError());
return std::move(*E);
}

/// Auto-unwrap an Expected<T> value in the success state. It is a programmatic
/// error to call this function on a failure value.
template <typename T> T &cantFail(Expected<T &> E) {
assert(E && "cantFail called on failure value");
consumeError(E.takeError());
return *E;
}

/// Convert the given error to a string. The error value is consumed in the
/// process.
inline std::string toString(Error Err) {
if (auto EIB = error_cast<ErrorInfoBase>(Err))
return EIB->toString();
return {};
}

class StringError : public RTTIExtends<StringError, ErrorInfoBase> {
public:
StringError(std::string ErrMsg) : ErrMsg(std::move(ErrMsg)) {}
std::string toString() const override { return ErrMsg; }

private:
std::string ErrMsg;
};

} // end namespace __orc_rt

#endif // ORC_RT_ERROR_H
1 change: 1 addition & 0 deletions compiler-rt/lib/orc/unittests/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,6 +80,7 @@ macro(add_orc_unittest testname)
endmacro()

set(UNITTEST_SOURCES
error_test.cpp
extensible_rtti_test.cpp
orc_unit_test_main.cpp
stl_extras_test.cpp
Expand Down
295 changes: 295 additions & 0 deletions compiler-rt/lib/orc/unittests/error_test.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,295 @@
//===-- error_test.cpp --sssssssss-----------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file is a part of the ORC runtime.
//
// Note:
// This unit test was adapted from
// llvm/unittests/Support/ExtensibleRTTITest.cpp
//
//===----------------------------------------------------------------------===//

#include "error.h"
#include "gtest/gtest.h"

using namespace __orc_rt;

namespace {

class CustomError : public RTTIExtends<CustomError, ErrorInfoBase> {
public:
CustomError(int V1) : V1(V1) {}
std::string toString() const override {
return "CustomError V1 = " + std::to_string(V1);
}
int getV1() const { return V1; }

protected:
int V1;
};

class CustomSubError : public RTTIExtends<CustomSubError, CustomError> {
public:
CustomSubError(int V1, std::string V2)
: RTTIExtends<CustomSubError, CustomError>(V1), V2(std::move(V2)) {}
std::string toString() const override {
return "CustomSubError V1 = " + std::to_string(V1) + ", " + V2;
}
const std::string &getV2() const { return V2; }

protected:
std::string V2;
};

} // end anonymous namespace

// Test that a checked success value doesn't cause any issues.
TEST(Error, CheckedSuccess) {
Error E = Error::success();
EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
}

// Check that a consumed success value doesn't cause any issues.
TEST(Error, ConsumeSuccess) { consumeError(Error::success()); }

TEST(Error, ConsumeError) {
Error E = make_error<CustomError>(42);
if (E) {
consumeError(std::move(E));
} else
ADD_FAILURE() << "Error failure value should convert to true";
}

// Test that unchecked success values cause an abort.
TEST(Error, UncheckedSuccess) {
EXPECT_DEATH({ Error E = Error::success(); },
"Error must be checked prior to destruction")
<< "Unchecked Error Succes value did not cause abort()";
}

// Test that a checked but unhandled error causes an abort.
TEST(Error, CheckedButUnhandledError) {
auto DropUnhandledError = []() {
Error E = make_error<CustomError>(42);
(void)!E;
};
EXPECT_DEATH(DropUnhandledError(),
"Error must be checked prior to destruction")
<< "Unhandled Error failure value did not cause an abort()";
}

// Test that error_cast works as expected.
TEST(Error, BasicErrorCast) {
{
// Check casting base error value to base error type.
auto E = make_error<CustomError>(42);
if (auto CSE = error_cast<CustomSubError>(E)) {
ADD_FAILURE() << "Derived cast incorrectly matched base error";
} else if (auto CE = error_cast<CustomError>(E)) {
EXPECT_EQ(CE->getV1(), 42) << "Unexpected wrapped value";
} else
ADD_FAILURE() << "Unexpected error value";
}

{
// Check casting derived error value to base error type.
auto E = make_error<CustomSubError>(42, "foo");
if (auto CE = error_cast<CustomError>(E)) {
EXPECT_EQ(CE->getV1(), 42) << "Unexpected wrapped value";
} else
ADD_FAILURE() << "Unexpected error value";
}

{
// Check casting derived error value to derived error type.
auto E = make_error<CustomSubError>(42, "foo");
if (auto CSE = error_cast<CustomSubError>(E)) {
EXPECT_EQ(CSE->getV1(), 42) << "Unexpected wrapped value";
EXPECT_EQ(CSE->getV2(), "foo") << "Unexpected wrapped value";
} else
ADD_FAILURE() << "Unexpected error value";
}
}

// ErrorAsOutParameter tester.
static void errAsOutParamHelper(Error &Err) {
ErrorAsOutParameter ErrAsOutParam(&Err);
// Verify that checked flag is raised - assignment should not crash.
Err = Error::success();
// Raise the checked bit manually - caller should still have to test the
// error.
(void)!!Err;
}

// Test that ErrorAsOutParameter sets the checked flag on construction.
TEST(Error, ErrorAsOutParameterChecked) {
Error E = Error::success();
errAsOutParamHelper(E);
(void)!!E;
}

// Test that ErrorAsOutParameter clears the checked flag on destruction.
TEST(Error, ErrorAsOutParameterUnchecked) {
EXPECT_DEATH(
{
Error E = Error::success();
errAsOutParamHelper(E);
},
"Error must be checked prior to destruction")
<< "ErrorAsOutParameter did not clear the checked flag on destruction.";
}

// Check 'Error::isA<T>' method handling.
TEST(Error, IsAHandling) {
// Check 'isA' handling.
Error E = make_error<CustomError>(42);
Error F = make_error<CustomSubError>(42, "foo");
Error G = Error::success();

EXPECT_TRUE(E.isA<CustomError>());
EXPECT_FALSE(E.isA<CustomSubError>());
EXPECT_TRUE(F.isA<CustomError>());
EXPECT_TRUE(F.isA<CustomSubError>());
EXPECT_FALSE(G.isA<CustomError>());

consumeError(std::move(E));
consumeError(std::move(F));
consumeError(std::move(G));
}

TEST(Error, StringError) {
auto E = make_error<StringError>("foo");
if (auto SE = error_cast<StringError>(E)) {
EXPECT_EQ(SE->toString(), "foo") << "Unexpected StringError value";
} else
ADD_FAILURE() << "Expected StringError value";
}

// Test Checked Expected<T> in success mode.
TEST(Error, CheckedExpectedInSuccessMode) {
Expected<int> A = 7;
EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
// Access is safe in second test, since we checked the error in the first.
EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
}

// Test Expected with reference type.
TEST(Error, ExpectedWithReferenceType) {
int A = 7;
Expected<int &> B = A;
// 'Check' B.
(void)!!B;
int &C = *B;
EXPECT_EQ(&A, &C) << "Expected failed to propagate reference";
}

// Test Unchecked Expected<T> in success mode.
// We expect this to blow up the same way Error would.
// Test runs in debug mode only.
TEST(Error, UncheckedExpectedInSuccessModeDestruction) {
EXPECT_DEATH({ Expected<int> A = 7; },
"Expected<T> must be checked before access or destruction.")
<< "Unchecekd Expected<T> success value did not cause an abort().";
}

// Test Unchecked Expected<T> in success mode.
// We expect this to blow up the same way Error would.
// Test runs in debug mode only.
TEST(Error, UncheckedExpectedInSuccessModeAccess) {
EXPECT_DEATH(
{
Expected<int> A = 7;
*A;
},
"Expected<T> must be checked before access or destruction.")
<< "Unchecekd Expected<T> success value did not cause an abort().";
}

// Test Unchecked Expected<T> in success mode.
// We expect this to blow up the same way Error would.
// Test runs in debug mode only.
TEST(Error, UncheckedExpectedInSuccessModeAssignment) {
EXPECT_DEATH(
{
Expected<int> A = 7;
A = 7;
},
"Expected<T> must be checked before access or destruction.")
<< "Unchecekd Expected<T> success value did not cause an abort().";
}

// Test Expected<T> in failure mode.
TEST(Error, ExpectedInFailureMode) {
Expected<int> A = make_error<CustomError>(42);
EXPECT_FALSE(!!A) << "Expected with error value doesn't convert to 'false'";
Error E = A.takeError();
EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
consumeError(std::move(E));
}

// Check that an Expected instance with an error value doesn't allow access to
// operator*.
// Test runs in debug mode only.
TEST(Error, AccessExpectedInFailureMode) {
Expected<int> A = make_error<CustomError>(42);
EXPECT_DEATH(*A, "Expected<T> must be checked before access or destruction.")
<< "Incorrect Expected error value";
consumeError(A.takeError());
}

// Check that an Expected instance with an error triggers an abort if
// unhandled.
// Test runs in debug mode only.
TEST(Error, UnhandledExpectedInFailureMode) {
EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); },
"Expected<T> must be checked before access or destruction.")
<< "Unchecked Expected<T> failure value did not cause an abort()";
}

// Test covariance of Expected.
TEST(Error, ExpectedCovariance) {
class B {};
class D : public B {};

Expected<B *> A1(Expected<D *>(nullptr));
// Check A1 by converting to bool before assigning to it.
(void)!!A1;
A1 = Expected<D *>(nullptr);
// Check A1 again before destruction.
(void)!!A1;

Expected<std::unique_ptr<B>> A2(Expected<std::unique_ptr<D>>(nullptr));
// Check A2 by converting to bool before assigning to it.
(void)!!A2;
A2 = Expected<std::unique_ptr<D>>(nullptr);
// Check A2 again before destruction.
(void)!!A2;
}

// Test that the ExitOnError utility works as expected.
TEST(Error, CantFailSuccess) {
cantFail(Error::success());

int X = cantFail(Expected<int>(42));
EXPECT_EQ(X, 42) << "Expected value modified by cantFail";

int Dummy = 42;
int &Y = cantFail(Expected<int &>(Dummy));
EXPECT_EQ(&Dummy, &Y) << "Reference mangled by cantFail";
}

// Test that cantFail results in a crash if you pass it a failure value.
TEST(Error, CantFailDeath) {
EXPECT_DEATH(cantFail(make_error<StringError>("foo")),
"cantFail called on failure value")
<< "cantFail(Error) did not cause an abort for failure value";

EXPECT_DEATH(cantFail(Expected<int>(make_error<StringError>("foo"))),
"cantFail called on failure value")
<< "cantFail(Expected<int>) did not cause an abort for failure value";
}
3 changes: 3 additions & 0 deletions llvm/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -79,6 +79,9 @@ class JITTargetMachineBuilder {
return *this;
}

/// Returns the CPU string.
const std::string &getCPU() const { return CPU; }

/// Set the relocation model.
JITTargetMachineBuilder &setRelocationModel(Optional<Reloc::Model> RM) {
this->RM = std::move(RM);
Expand Down