| //===- 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 |