579 lines
18 KiB
C++
579 lines
18 KiB
C++
|
//===- ValueHandleTest.cpp - ValueHandle tests ----------------------------===//
|
||
|
|
//
|
||
|
|
// 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
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "llvm/IR/ValueHandle.h"
|
||
|
|
#include "llvm/IR/Constants.h"
|
||
|
|
#include "llvm/IR/Instructions.h"
|
||
|
|
#include "llvm/IR/LLVMContext.h"
|
||
|
|
#include "gtest/gtest.h"
|
||
|
|
#include <memory>
|
||
|
|
|
||
|
|
using namespace llvm;
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
class ValueHandle : public testing::Test {
|
||
|
|
protected:
|
||
|
|
LLVMContext Context;
|
||
|
|
Constant *ConstantV;
|
||
|
|
std::unique_ptr<BitCastInst> BitcastV;
|
||
|
|
|
||
|
|
ValueHandle()
|
||
|
|
: ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
|
||
|
|
BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
class ConcreteCallbackVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, WeakVH_BasicOperation) {
|
||
|
|
WeakVH WVH(BitcastV.get());
|
||
|
|
EXPECT_EQ(BitcastV.get(), WVH);
|
||
|
|
WVH = ConstantV;
|
||
|
|
EXPECT_EQ(ConstantV, WVH);
|
||
|
|
|
||
|
|
// Make sure I can call a method on the underlying Value. It
|
||
|
|
// doesn't matter which method.
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
|
||
|
|
|
||
|
|
WVH = BitcastV.get();
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(WVH, BitcastV.get());
|
||
|
|
BitcastV.reset();
|
||
|
|
EXPECT_EQ(WVH, nullptr);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, WeakTrackingVH_BasicOperation) {
|
||
|
|
WeakTrackingVH WVH(BitcastV.get());
|
||
|
|
EXPECT_EQ(BitcastV.get(), WVH);
|
||
|
|
WVH = ConstantV;
|
||
|
|
EXPECT_EQ(ConstantV, WVH);
|
||
|
|
|
||
|
|
// Make sure I can call a method on the underlying Value. It
|
||
|
|
// doesn't matter which method.
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, WeakTrackingVH_Comparisons) {
|
||
|
|
WeakTrackingVH BitcastWVH(BitcastV.get());
|
||
|
|
WeakTrackingVH ConstantWVH(ConstantV);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastWVH == BitcastWVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() == BitcastWVH);
|
||
|
|
EXPECT_TRUE(BitcastWVH == BitcastV.get());
|
||
|
|
EXPECT_FALSE(BitcastWVH == ConstantWVH);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastWVH != ConstantWVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() != ConstantWVH);
|
||
|
|
EXPECT_TRUE(BitcastWVH != ConstantV);
|
||
|
|
EXPECT_FALSE(BitcastWVH != BitcastWVH);
|
||
|
|
|
||
|
|
// Cast to Value* so comparisons work.
|
||
|
|
Value *BV = BitcastV.get();
|
||
|
|
Value *CV = ConstantV;
|
||
|
|
EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, WeakTrackingVH_FollowsRAUW) {
|
||
|
|
WeakTrackingVH WVH(BitcastV.get());
|
||
|
|
WeakTrackingVH WVH_Copy(WVH);
|
||
|
|
WeakTrackingVH WVH_Recreated(BitcastV.get());
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(ConstantV, WVH);
|
||
|
|
EXPECT_EQ(ConstantV, WVH_Copy);
|
||
|
|
EXPECT_EQ(ConstantV, WVH_Recreated);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, WeakTrackingVH_NullOnDeletion) {
|
||
|
|
WeakTrackingVH WVH(BitcastV.get());
|
||
|
|
WeakTrackingVH WVH_Copy(WVH);
|
||
|
|
WeakTrackingVH WVH_Recreated(BitcastV.get());
|
||
|
|
BitcastV.reset();
|
||
|
|
Value *null_value = nullptr;
|
||
|
|
EXPECT_EQ(null_value, WVH);
|
||
|
|
EXPECT_EQ(null_value, WVH_Copy);
|
||
|
|
EXPECT_EQ(null_value, WVH_Recreated);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_BasicOperation) {
|
||
|
|
AssertingVH<CastInst> AVH(BitcastV.get());
|
||
|
|
CastInst *implicit_to_exact_type = AVH;
|
||
|
|
(void)implicit_to_exact_type; // Avoid warning.
|
||
|
|
|
||
|
|
AssertingVH<Value> GenericAVH(BitcastV.get());
|
||
|
|
EXPECT_EQ(BitcastV.get(), GenericAVH);
|
||
|
|
GenericAVH = ConstantV;
|
||
|
|
EXPECT_EQ(ConstantV, GenericAVH);
|
||
|
|
|
||
|
|
// Make sure I can call a method on the underlying CastInst. It
|
||
|
|
// doesn't matter which method.
|
||
|
|
EXPECT_FALSE(AVH->mayWriteToMemory());
|
||
|
|
EXPECT_FALSE((*AVH).mayWriteToMemory());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_Const) {
|
||
|
|
const CastInst *ConstBitcast = BitcastV.get();
|
||
|
|
AssertingVH<const CastInst> AVH(ConstBitcast);
|
||
|
|
const CastInst *implicit_to_exact_type = AVH;
|
||
|
|
(void)implicit_to_exact_type; // Avoid warning.
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_Comparisons) {
|
||
|
|
AssertingVH<Value> BitcastAVH(BitcastV.get());
|
||
|
|
AssertingVH<Value> ConstantAVH(ConstantV);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastAVH == BitcastAVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() == BitcastAVH);
|
||
|
|
EXPECT_TRUE(BitcastAVH == BitcastV.get());
|
||
|
|
EXPECT_FALSE(BitcastAVH == ConstantAVH);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastAVH != ConstantAVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() != ConstantAVH);
|
||
|
|
EXPECT_TRUE(BitcastAVH != ConstantV);
|
||
|
|
EXPECT_FALSE(BitcastAVH != BitcastAVH);
|
||
|
|
|
||
|
|
// Cast to Value* so comparisons work.
|
||
|
|
Value *BV = BitcastV.get();
|
||
|
|
Value *CV = ConstantV;
|
||
|
|
EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) {
|
||
|
|
AssertingVH<Value> AVH(BitcastV.get());
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(BitcastV.get(), AVH);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef NDEBUG
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_ReducesToPointer) {
|
||
|
|
EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH<CastInst>));
|
||
|
|
}
|
||
|
|
|
||
|
|
#elif LLVM_ENABLE_ABI_BREAKING_CHECKS // && !NDEBUG
|
||
|
|
|
||
|
|
#ifdef GTEST_HAS_DEATH_TEST
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_Asserts) {
|
||
|
|
AssertingVH<Value> AVH(BitcastV.get());
|
||
|
|
EXPECT_DEATH({BitcastV.reset();},
|
||
|
|
"An asserting value handle still pointed to this value!");
|
||
|
|
AssertingVH<Value> Copy(AVH);
|
||
|
|
AVH = nullptr;
|
||
|
|
EXPECT_DEATH({BitcastV.reset();},
|
||
|
|
"An asserting value handle still pointed to this value!");
|
||
|
|
Copy = nullptr;
|
||
|
|
BitcastV.reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // GTEST_HAS_DEATH_TEST
|
||
|
|
|
||
|
|
#endif // NDEBUG
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, CallbackVH_BasicOperation) {
|
||
|
|
ConcreteCallbackVH CVH(BitcastV.get());
|
||
|
|
EXPECT_EQ(BitcastV.get(), CVH);
|
||
|
|
CVH = ConstantV;
|
||
|
|
EXPECT_EQ(ConstantV, CVH);
|
||
|
|
|
||
|
|
// Make sure I can call a method on the underlying Value. It
|
||
|
|
// doesn't matter which method.
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType());
|
||
|
|
EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, CallbackVH_Comparisons) {
|
||
|
|
ConcreteCallbackVH BitcastCVH(BitcastV.get());
|
||
|
|
ConcreteCallbackVH ConstantCVH(ConstantV);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastCVH == BitcastCVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() == BitcastCVH);
|
||
|
|
EXPECT_TRUE(BitcastCVH == BitcastV.get());
|
||
|
|
EXPECT_FALSE(BitcastCVH == ConstantCVH);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastCVH != ConstantCVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() != ConstantCVH);
|
||
|
|
EXPECT_TRUE(BitcastCVH != ConstantV);
|
||
|
|
EXPECT_FALSE(BitcastCVH != BitcastCVH);
|
||
|
|
|
||
|
|
// Cast to Value* so comparisons work.
|
||
|
|
Value *BV = BitcastV.get();
|
||
|
|
Value *CV = ConstantV;
|
||
|
|
EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastV.get() < ConstantCVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantCVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastV.get() > ConstantCVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, CallbackVH_CallbackOnDeletion) {
|
||
|
|
class RecordingVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
int DeletedCalls;
|
||
|
|
int AURWCalls;
|
||
|
|
|
||
|
|
RecordingVH() : DeletedCalls(0), AURWCalls(0) {}
|
||
|
|
RecordingVH(Value *V) : CallbackVH(V), DeletedCalls(0), AURWCalls(0) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
void deleted() override {
|
||
|
|
DeletedCalls++;
|
||
|
|
CallbackVH::deleted();
|
||
|
|
}
|
||
|
|
void allUsesReplacedWith(Value *) override { AURWCalls++; }
|
||
|
|
};
|
||
|
|
|
||
|
|
RecordingVH RVH;
|
||
|
|
RVH = BitcastV.get();
|
||
|
|
EXPECT_EQ(0, RVH.DeletedCalls);
|
||
|
|
EXPECT_EQ(0, RVH.AURWCalls);
|
||
|
|
BitcastV.reset();
|
||
|
|
EXPECT_EQ(1, RVH.DeletedCalls);
|
||
|
|
EXPECT_EQ(0, RVH.AURWCalls);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, CallbackVH_CallbackOnRAUW) {
|
||
|
|
class RecordingVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
int DeletedCalls;
|
||
|
|
Value *AURWArgument;
|
||
|
|
|
||
|
|
RecordingVH() : DeletedCalls(0), AURWArgument(nullptr) {}
|
||
|
|
RecordingVH(Value *V)
|
||
|
|
: CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
void deleted() override {
|
||
|
|
DeletedCalls++;
|
||
|
|
CallbackVH::deleted();
|
||
|
|
}
|
||
|
|
void allUsesReplacedWith(Value *new_value) override {
|
||
|
|
EXPECT_EQ(nullptr, AURWArgument);
|
||
|
|
AURWArgument = new_value;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
RecordingVH RVH;
|
||
|
|
RVH = BitcastV.get();
|
||
|
|
EXPECT_EQ(0, RVH.DeletedCalls);
|
||
|
|
EXPECT_EQ(nullptr, RVH.AURWArgument);
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(0, RVH.DeletedCalls);
|
||
|
|
EXPECT_EQ(ConstantV, RVH.AURWArgument);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
|
||
|
|
class RecoveringVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
int DeletedCalls;
|
||
|
|
Value *AURWArgument;
|
||
|
|
LLVMContext *Context;
|
||
|
|
|
||
|
|
RecoveringVH(LLVMContext &TheContext)
|
||
|
|
: DeletedCalls(0), AURWArgument(nullptr), Context(&TheContext) {}
|
||
|
|
|
||
|
|
RecoveringVH(LLVMContext &TheContext, Value *V)
|
||
|
|
: CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr),
|
||
|
|
Context(&TheContext) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
void deleted() override {
|
||
|
|
getValPtr()->replaceAllUsesWith(
|
||
|
|
Constant::getNullValue(Type::getInt32Ty(*Context)));
|
||
|
|
setValPtr(nullptr);
|
||
|
|
}
|
||
|
|
void allUsesReplacedWith(Value *new_value) override {
|
||
|
|
ASSERT_TRUE(nullptr != getValPtr());
|
||
|
|
EXPECT_EQ(1U, getValPtr()->getNumUses());
|
||
|
|
EXPECT_EQ(nullptr, AURWArgument);
|
||
|
|
AURWArgument = new_value;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// Normally, if a value has uses, deleting it will crash. However, we can use
|
||
|
|
// a CallbackVH to remove the uses before the check for no uses.
|
||
|
|
RecoveringVH RVH(Context);
|
||
|
|
RVH = RecoveringVH(Context, BitcastV.get());
|
||
|
|
std::unique_ptr<BinaryOperator> BitcastUser(BinaryOperator::CreateAdd(
|
||
|
|
RVH, Constant::getNullValue(Type::getInt32Ty(Context))));
|
||
|
|
EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
|
||
|
|
BitcastV.reset(); // Would crash without the ValueHandler.
|
||
|
|
EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
|
||
|
|
RVH.AURWArgument);
|
||
|
|
EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
|
||
|
|
BitcastUser->getOperand(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
|
||
|
|
// When a CallbackVH modifies other ValueHandles in its callbacks,
|
||
|
|
// that shouldn't interfere with non-modified ValueHandles receiving
|
||
|
|
// their appropriate callbacks.
|
||
|
|
//
|
||
|
|
// We create the active CallbackVH in the middle of a palindromic
|
||
|
|
// arrangement of other VHs so that the bad behavior would be
|
||
|
|
// triggered in whichever order callbacks run.
|
||
|
|
|
||
|
|
class DestroyingVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
std::unique_ptr<WeakTrackingVH> ToClear[2];
|
||
|
|
DestroyingVH(Value *V) {
|
||
|
|
ToClear[0].reset(new WeakTrackingVH(V));
|
||
|
|
setValPtr(V);
|
||
|
|
ToClear[1].reset(new WeakTrackingVH(V));
|
||
|
|
}
|
||
|
|
void deleted() override {
|
||
|
|
ToClear[0].reset();
|
||
|
|
ToClear[1].reset();
|
||
|
|
CallbackVH::deleted();
|
||
|
|
}
|
||
|
|
void allUsesReplacedWith(Value *) override {
|
||
|
|
ToClear[0].reset();
|
||
|
|
ToClear[1].reset();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
{
|
||
|
|
WeakTrackingVH ShouldBeVisited1(BitcastV.get());
|
||
|
|
DestroyingVH C(BitcastV.get());
|
||
|
|
WeakTrackingVH ShouldBeVisited2(BitcastV.get());
|
||
|
|
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
|
||
|
|
EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
WeakTrackingVH ShouldBeVisited1(BitcastV.get());
|
||
|
|
DestroyingVH C(BitcastV.get());
|
||
|
|
WeakTrackingVH ShouldBeVisited2(BitcastV.get());
|
||
|
|
|
||
|
|
BitcastV.reset();
|
||
|
|
EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited1));
|
||
|
|
EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited2));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVHCheckedLast) {
|
||
|
|
// If a CallbackVH exists to clear out a group of AssertingVHs on
|
||
|
|
// Value deletion, the CallbackVH should get a chance to do so
|
||
|
|
// before the AssertingVHs assert.
|
||
|
|
|
||
|
|
class ClearingVH final : public CallbackVH {
|
||
|
|
public:
|
||
|
|
AssertingVH<Value> *ToClear[2];
|
||
|
|
ClearingVH(Value *V,
|
||
|
|
AssertingVH<Value> &A0, AssertingVH<Value> &A1)
|
||
|
|
: CallbackVH(V) {
|
||
|
|
ToClear[0] = &A0;
|
||
|
|
ToClear[1] = &A1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void deleted() override {
|
||
|
|
*ToClear[0] = nullptr;
|
||
|
|
*ToClear[1] = nullptr;
|
||
|
|
CallbackVH::deleted();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
AssertingVH<Value> A1, A2;
|
||
|
|
A1 = BitcastV.get();
|
||
|
|
ClearingVH C(BitcastV.get(), A1, A2);
|
||
|
|
A2 = BitcastV.get();
|
||
|
|
// C.deleted() should run first, clearing the two AssertingVHs,
|
||
|
|
// which should prevent them from asserting.
|
||
|
|
BitcastV.reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_BasicOperation) {
|
||
|
|
PoisoningVH<CastInst> VH(BitcastV.get());
|
||
|
|
CastInst *implicit_to_exact_type = VH;
|
||
|
|
(void)implicit_to_exact_type; // Avoid warning.
|
||
|
|
|
||
|
|
PoisoningVH<Value> GenericVH(BitcastV.get());
|
||
|
|
EXPECT_EQ(BitcastV.get(), GenericVH);
|
||
|
|
GenericVH = ConstantV;
|
||
|
|
EXPECT_EQ(ConstantV, GenericVH);
|
||
|
|
|
||
|
|
// Make sure I can call a method on the underlying CastInst. It
|
||
|
|
// doesn't matter which method.
|
||
|
|
EXPECT_FALSE(VH->mayWriteToMemory());
|
||
|
|
EXPECT_FALSE((*VH).mayWriteToMemory());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_Const) {
|
||
|
|
const CastInst *ConstBitcast = BitcastV.get();
|
||
|
|
PoisoningVH<const CastInst> VH(ConstBitcast);
|
||
|
|
const CastInst *implicit_to_exact_type = VH;
|
||
|
|
(void)implicit_to_exact_type; // Avoid warning.
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_Comparisons) {
|
||
|
|
PoisoningVH<Value> BitcastVH(BitcastV.get());
|
||
|
|
PoisoningVH<Value> ConstantVH(ConstantV);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastVH == BitcastVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() == BitcastVH);
|
||
|
|
EXPECT_TRUE(BitcastVH == BitcastV.get());
|
||
|
|
EXPECT_FALSE(BitcastVH == ConstantVH);
|
||
|
|
|
||
|
|
EXPECT_TRUE(BitcastVH != ConstantVH);
|
||
|
|
EXPECT_TRUE(BitcastV.get() != ConstantVH);
|
||
|
|
EXPECT_TRUE(BitcastVH != ConstantV);
|
||
|
|
EXPECT_FALSE(BitcastVH != BitcastVH);
|
||
|
|
|
||
|
|
// Cast to Value* so comparisons work.
|
||
|
|
Value *BV = BitcastV.get();
|
||
|
|
Value *CV = ConstantV;
|
||
|
|
EXPECT_EQ(BV < CV, BitcastVH < ConstantVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastVH <= ConstantVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastVH > ConstantVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastVH >= ConstantVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastV.get() < ConstantVH);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantVH);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastV.get() > ConstantVH);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantVH);
|
||
|
|
|
||
|
|
EXPECT_EQ(BV < CV, BitcastVH < ConstantV);
|
||
|
|
EXPECT_EQ(BV <= CV, BitcastVH <= ConstantV);
|
||
|
|
EXPECT_EQ(BV > CV, BitcastVH > ConstantV);
|
||
|
|
EXPECT_EQ(BV >= CV, BitcastVH >= ConstantV);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_DoesNotFollowRAUW) {
|
||
|
|
PoisoningVH<Value> VH(BitcastV.get());
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_TRUE(DenseMapInfo<PoisoningVH<Value>>::isEqual(VH, BitcastV.get()));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, AssertingVH_DenseMap) {
|
||
|
|
DenseMap<AssertingVH<Value>, int> Map;
|
||
|
|
Map.insert({BitcastV.get(), 1});
|
||
|
|
Map.insert({ConstantV, 2});
|
||
|
|
// These will create a temporary AssertingVH during lookup.
|
||
|
|
EXPECT_TRUE(Map.find(BitcastV.get()) != Map.end());
|
||
|
|
EXPECT_TRUE(Map.find(ConstantV) != Map.end());
|
||
|
|
// These will not create a temporary AssertingVH.
|
||
|
|
EXPECT_TRUE(Map.find_as(BitcastV.get()) != Map.end());
|
||
|
|
EXPECT_TRUE(Map.find_as(ConstantV) != Map.end());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_DenseMap) {
|
||
|
|
DenseMap<PoisoningVH<Value>, int> Map;
|
||
|
|
Map.insert({BitcastV.get(), 1});
|
||
|
|
Map.insert({ConstantV, 2});
|
||
|
|
// These will create a temporary PoisoningVH during lookup.
|
||
|
|
EXPECT_TRUE(Map.find(BitcastV.get()) != Map.end());
|
||
|
|
EXPECT_TRUE(Map.find(ConstantV) != Map.end());
|
||
|
|
// These will not create a temporary PoisoningVH.
|
||
|
|
EXPECT_TRUE(Map.find_as(BitcastV.get()) != Map.end());
|
||
|
|
EXPECT_TRUE(Map.find_as(ConstantV) != Map.end());
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef NDEBUG
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_ReducesToPointer) {
|
||
|
|
EXPECT_EQ(sizeof(CastInst *), sizeof(PoisoningVH<CastInst>));
|
||
|
|
}
|
||
|
|
|
||
|
|
#else // !NDEBUG
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, TrackingVH_Tracks) {
|
||
|
|
TrackingVH<Value> VH(BitcastV.get());
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_EQ(VH, ConstantV);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef GTEST_HAS_DEATH_TEST
|
||
|
|
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, PoisoningVH_Asserts) {
|
||
|
|
PoisoningVH<Value> VH(BitcastV.get());
|
||
|
|
|
||
|
|
// The poisoned handle shouldn't assert when the value is deleted.
|
||
|
|
BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
|
||
|
|
// But should when we access the handle.
|
||
|
|
EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
|
||
|
|
|
||
|
|
// Now check that poison catches RAUW.
|
||
|
|
VH = BitcastV.get();
|
||
|
|
// The replace doesn't trigger anything immediately.
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
// But a use does.
|
||
|
|
EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
|
||
|
|
|
||
|
|
// Don't clear anything out here as destroying the handles should be fine.
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
|
||
|
|
|
||
|
|
TEST_F(ValueHandle, TrackingVH_Asserts) {
|
||
|
|
{
|
||
|
|
TrackingVH<Value> VH(BitcastV.get());
|
||
|
|
|
||
|
|
// The tracking handle shouldn't assert when the value is deleted.
|
||
|
|
BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
|
||
|
|
// But should when we access the handle.
|
||
|
|
EXPECT_DEATH((void)*VH,
|
||
|
|
"TrackingVH must be non-null and valid on dereference!");
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
TrackingVH<Instruction> VH(BitcastV.get());
|
||
|
|
|
||
|
|
BitcastV->replaceAllUsesWith(ConstantV);
|
||
|
|
EXPECT_DEATH((void)*VH,
|
||
|
|
"Tracked Value was replaced by one with an invalid type!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // GTEST_HAS_DEATH_TEST
|
||
|
|
|
||
|
|
#endif // NDEBUG
|
||
|
|
}
|