diff options
Diffstat (limited to 'gnu/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp')
| -rw-r--r-- | gnu/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp | 350 |
1 files changed, 0 insertions, 350 deletions
diff --git a/gnu/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp b/gnu/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp deleted file mode 100644 index 94ac76bb076..00000000000 --- a/gnu/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp +++ /dev/null @@ -1,350 +0,0 @@ -//===- ValueMapper.cpp - Unit tests for ValueMapper -----------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Transforms/Utils/ValueMapper.h" -#include "llvm/IR/Constants.h" -#include "llvm/IR/Function.h" -#include "llvm/IR/GlobalVariable.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/IR/Metadata.h" -#include "gtest/gtest.h" - -using namespace llvm; - -namespace { - -TEST(ValueMapperTest, mapMDNode) { - LLVMContext Context; - auto *U = MDTuple::get(Context, None); - - // The node should be unchanged. - ValueToValueMapTy VM; - EXPECT_EQ(U, ValueMapper(VM).mapMDNode(*U)); -} - -TEST(ValueMapperTest, mapMDNodeCycle) { - LLVMContext Context; - MDNode *U0; - MDNode *U1; - { - Metadata *Ops[] = {nullptr}; - auto T = MDTuple::getTemporary(Context, Ops); - Ops[0] = T.get(); - U0 = MDTuple::get(Context, Ops); - T->replaceOperandWith(0, U0); - U1 = MDNode::replaceWithUniqued(std::move(T)); - U0->resolveCycles(); - } - - EXPECT_TRUE(U0->isResolved()); - EXPECT_TRUE(U0->isUniqued()); - EXPECT_TRUE(U1->isResolved()); - EXPECT_TRUE(U1->isUniqued()); - EXPECT_EQ(U1, U0->getOperand(0)); - EXPECT_EQ(U0, U1->getOperand(0)); - - // Cycles shouldn't be duplicated. - { - ValueToValueMapTy VM; - EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0)); - EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1)); - } - - // Check the other order. - { - ValueToValueMapTy VM; - EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1)); - EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0)); - } -} - -TEST(ValueMapperTest, mapMDNodeDuplicatedCycle) { - LLVMContext Context; - auto *PtrTy = Type::getInt8Ty(Context)->getPointerTo(); - std::unique_ptr<GlobalVariable> G0 = llvm::make_unique<GlobalVariable>( - PtrTy, false, GlobalValue::ExternalLinkage, nullptr, "G0"); - std::unique_ptr<GlobalVariable> G1 = llvm::make_unique<GlobalVariable>( - PtrTy, false, GlobalValue::ExternalLinkage, nullptr, "G1"); - - // Create a cycle that references G0. - MDNode *N0; // !0 = !{!1} - MDNode *N1; // !1 = !{!0, i8* @G0} - { - auto T0 = MDTuple::getTemporary(Context, nullptr); - Metadata *Ops1[] = {T0.get(), ConstantAsMetadata::get(G0.get())}; - N1 = MDTuple::get(Context, Ops1); - T0->replaceOperandWith(0, N1); - N0 = MDNode::replaceWithUniqued(std::move(T0)); - } - - // Resolve N0 and N1. - ASSERT_FALSE(N0->isResolved()); - ASSERT_FALSE(N1->isResolved()); - N0->resolveCycles(); - ASSERT_TRUE(N0->isResolved()); - ASSERT_TRUE(N1->isResolved()); - - // Seed the value map to map G0 to G1 and map the nodes. The output should - // have new nodes that reference G1 (instead of G0). - ValueToValueMapTy VM; - VM[G0.get()] = G1.get(); - MDNode *MappedN0 = ValueMapper(VM).mapMDNode(*N0); - MDNode *MappedN1 = ValueMapper(VM).mapMDNode(*N1); - EXPECT_NE(N0, MappedN0); - EXPECT_NE(N1, MappedN1); - EXPECT_EQ(ConstantAsMetadata::get(G1.get()), MappedN1->getOperand(1)); - - // Check that the output nodes are resolved. - EXPECT_TRUE(MappedN0->isResolved()); - EXPECT_TRUE(MappedN1->isResolved()); -} - -TEST(ValueMapperTest, mapMDNodeUnresolved) { - LLVMContext Context; - TempMDTuple T = MDTuple::getTemporary(Context, None); - - ValueToValueMapTy VM; - EXPECT_EQ(T.get(), ValueMapper(VM, RF_NoModuleLevelChanges).mapMDNode(*T)); -} - -TEST(ValueMapperTest, mapMDNodeDistinct) { - LLVMContext Context; - auto *D = MDTuple::getDistinct(Context, None); - - { - // The node should be cloned. - ValueToValueMapTy VM; - EXPECT_NE(D, ValueMapper(VM).mapMDNode(*D)); - } - { - // The node should be moved. - ValueToValueMapTy VM; - EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D)); - } -} - -TEST(ValueMapperTest, mapMDNodeDistinctOperands) { - LLVMContext Context; - Metadata *Old = MDTuple::getDistinct(Context, None); - auto *D = MDTuple::getDistinct(Context, Old); - ASSERT_EQ(Old, D->getOperand(0)); - - Metadata *New = MDTuple::getDistinct(Context, None); - ValueToValueMapTy VM; - VM.MD()[Old].reset(New); - - // Make sure operands are updated. - EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D)); - EXPECT_EQ(New, D->getOperand(0)); -} - -TEST(ValueMapperTest, mapMDNodeSeeded) { - LLVMContext Context; - auto *D = MDTuple::getDistinct(Context, None); - - // The node should be moved. - ValueToValueMapTy VM; - EXPECT_EQ(None, VM.getMappedMD(D)); - - VM.MD().insert(std::make_pair(D, TrackingMDRef(D))); - EXPECT_EQ(D, *VM.getMappedMD(D)); - EXPECT_EQ(D, ValueMapper(VM).mapMDNode(*D)); -} - -TEST(ValueMapperTest, mapMDNodeSeededWithNull) { - LLVMContext Context; - auto *D = MDTuple::getDistinct(Context, None); - - // The node should be moved. - ValueToValueMapTy VM; - EXPECT_EQ(None, VM.getMappedMD(D)); - - VM.MD().insert(std::make_pair(D, TrackingMDRef())); - EXPECT_EQ(nullptr, *VM.getMappedMD(D)); - EXPECT_EQ(nullptr, ValueMapper(VM).mapMDNode(*D)); -} - -TEST(ValueMapperTest, mapMetadataNullMapGlobalWithIgnoreMissingLocals) { - LLVMContext C; - FunctionType *FTy = - FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); - std::unique_ptr<Function> F( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); - - ValueToValueMapTy VM; - RemapFlags Flags = RF_IgnoreMissingLocals | RF_NullMapMissingGlobalValues; - EXPECT_EQ(nullptr, ValueMapper(VM, Flags).mapValue(*F)); -} - -TEST(ValueMapperTest, mapMetadataMDString) { - LLVMContext C; - auto *S1 = MDString::get(C, "S1"); - ValueToValueMapTy VM; - - // Make sure S1 maps to itself, but isn't memoized. - EXPECT_EQ(S1, ValueMapper(VM).mapMetadata(*S1)); - EXPECT_EQ(None, VM.getMappedMD(S1)); - - // We still expect VM.MD() to be respected. - auto *S2 = MDString::get(C, "S2"); - VM.MD()[S1].reset(S2); - EXPECT_EQ(S2, ValueMapper(VM).mapMetadata(*S1)); -} - -TEST(ValueMapperTest, mapMetadataGetMappedMD) { - LLVMContext C; - auto *N0 = MDTuple::get(C, None); - auto *N1 = MDTuple::get(C, N0); - - // Make sure hasMD and getMappedMD work correctly. - ValueToValueMapTy VM; - EXPECT_FALSE(VM.hasMD()); - EXPECT_EQ(N0, ValueMapper(VM).mapMetadata(*N0)); - EXPECT_EQ(N1, ValueMapper(VM).mapMetadata(*N1)); - EXPECT_TRUE(VM.hasMD()); - ASSERT_NE(None, VM.getMappedMD(N0)); - ASSERT_NE(None, VM.getMappedMD(N1)); - EXPECT_EQ(N0, *VM.getMappedMD(N0)); - EXPECT_EQ(N1, *VM.getMappedMD(N1)); -} - -TEST(ValueMapperTest, mapMetadataNoModuleLevelChanges) { - LLVMContext C; - auto *N0 = MDTuple::get(C, None); - auto *N1 = MDTuple::get(C, N0); - - // Nothing should be memoized when RF_NoModuleLevelChanges. - ValueToValueMapTy VM; - EXPECT_FALSE(VM.hasMD()); - EXPECT_EQ(N0, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N0)); - EXPECT_EQ(N1, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N1)); - EXPECT_FALSE(VM.hasMD()); - EXPECT_EQ(None, VM.getMappedMD(N0)); - EXPECT_EQ(None, VM.getMappedMD(N1)); -} - -TEST(ValueMapperTest, mapMetadataConstantAsMetadata) { - LLVMContext C; - FunctionType *FTy = - FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); - std::unique_ptr<Function> F( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); - - auto *CAM = ConstantAsMetadata::get(F.get()); - { - // ConstantAsMetadata shouldn't be memoized. - ValueToValueMapTy VM; - EXPECT_EQ(CAM, ValueMapper(VM).mapMetadata(*CAM)); - EXPECT_FALSE(VM.MD().count(CAM)); - EXPECT_EQ(CAM, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM)); - EXPECT_FALSE(VM.MD().count(CAM)); - - // But it should respect a mapping that gets seeded. - auto *N = MDTuple::get(C, None); - VM.MD()[CAM].reset(N); - EXPECT_EQ(N, ValueMapper(VM).mapMetadata(*CAM)); - EXPECT_EQ(N, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM)); - } - - std::unique_ptr<Function> F2( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F2")); - ValueToValueMapTy VM; - VM[F.get()] = F2.get(); - auto *F2MD = ValueMapper(VM).mapMetadata(*CAM); - EXPECT_FALSE(VM.MD().count(CAM)); - EXPECT_TRUE(F2MD); - EXPECT_EQ(F2.get(), cast<ConstantAsMetadata>(F2MD)->getValue()); -} - -#ifdef GTEST_HAS_DEATH_TEST -#ifndef NDEBUG -TEST(ValueMapperTest, mapMetadataLocalAsMetadata) { - LLVMContext C; - FunctionType *FTy = - FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); - std::unique_ptr<Function> F( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); - Argument &A = *F->arg_begin(); - - // mapMetadata doesn't support LocalAsMetadata. The only valid container for - // LocalAsMetadata is a MetadataAsValue instance, so use it directly. - auto *LAM = LocalAsMetadata::get(&A); - ValueToValueMapTy VM; - EXPECT_DEATH(ValueMapper(VM).mapMetadata(*LAM), "Unexpected local metadata"); - EXPECT_DEATH(ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*LAM), - "Unexpected local metadata"); -} -#endif -#endif - -TEST(ValueMapperTest, mapValueLocalAsMetadata) { - LLVMContext C; - FunctionType *FTy = - FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); - std::unique_ptr<Function> F( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); - Argument &A = *F->arg_begin(); - - auto *LAM = LocalAsMetadata::get(&A); - auto *MAV = MetadataAsValue::get(C, LAM); - - // The principled answer to a LocalAsMetadata of an unmapped SSA value would - // be to return nullptr (regardless of RF_IgnoreMissingLocals). - // - // However, algorithms that use RemapInstruction assume that each instruction - // only references SSA values from previous instructions. Arguments of - // such as "metadata i32 %x" don't currently successfully maintain that - // property. To keep RemapInstruction from crashing we need a non-null - // return here, but we also shouldn't reference the unmapped local. Use - // "metadata !{}". - auto *N0 = MDTuple::get(C, None); - auto *N0AV = MetadataAsValue::get(C, N0); - ValueToValueMapTy VM; - EXPECT_EQ(N0AV, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(nullptr, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); - EXPECT_FALSE(VM.count(MAV)); - EXPECT_FALSE(VM.count(&A)); - EXPECT_EQ(None, VM.getMappedMD(LAM)); - - VM[MAV] = MAV; - EXPECT_EQ(MAV, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(MAV, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); - EXPECT_TRUE(VM.count(MAV)); - EXPECT_FALSE(VM.count(&A)); - - VM[MAV] = &A; - EXPECT_EQ(&A, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(&A, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); - EXPECT_TRUE(VM.count(MAV)); - EXPECT_FALSE(VM.count(&A)); -} - -TEST(ValueMapperTest, mapValueLocalAsMetadataToConstant) { - LLVMContext Context; - auto *Int8 = Type::getInt8Ty(Context); - FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false); - std::unique_ptr<Function> F( - Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); - - // Map a local value to a constant. - Argument &A = *F->arg_begin(); - Constant &C = *ConstantInt::get(Int8, 42); - ValueToValueMapTy VM; - VM[&A] = &C; - - // Look up the metadata-as-value wrapper. Don't crash. - auto *MDA = MetadataAsValue::get(Context, ValueAsMetadata::get(&A)); - auto *MDC = MetadataAsValue::get(Context, ValueAsMetadata::get(&C)); - EXPECT_TRUE(isa<LocalAsMetadata>(MDA->getMetadata())); - EXPECT_TRUE(isa<ConstantAsMetadata>(MDC->getMetadata())); - EXPECT_EQ(&C, ValueMapper(VM).mapValue(A)); - EXPECT_EQ(MDC, ValueMapper(VM).mapValue(*MDA)); -} - -} // end namespace |