You've already forked linux-packaging-mono
Imported Upstream version 5.18.0.179
Former-commit-id: 67aa10e65b237e1c4537630979ee99ebe1374215
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
parent
d6bde52373
commit
8625704ad8
370
external/llvm/unittests/IR/PatternMatch.cpp
vendored
Normal file
370
external/llvm/unittests/IR/PatternMatch.cpp
vendored
Normal file
@ -0,0 +1,370 @@
|
||||
//===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/IR/PatternMatch.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/Analysis/ValueTracking.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DataLayout.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/IRBuilder.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/IR/MDBuilder.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/IR/NoFolder.h"
|
||||
#include "llvm/IR/Operator.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using namespace llvm;
|
||||
using namespace llvm::PatternMatch;
|
||||
|
||||
namespace {
|
||||
|
||||
struct PatternMatchTest : ::testing::Test {
|
||||
LLVMContext Ctx;
|
||||
std::unique_ptr<Module> M;
|
||||
Function *F;
|
||||
BasicBlock *BB;
|
||||
IRBuilder<NoFolder> IRB;
|
||||
|
||||
PatternMatchTest()
|
||||
: M(new Module("PatternMatchTestModule", Ctx)),
|
||||
F(Function::Create(
|
||||
FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
|
||||
Function::ExternalLinkage, "f", M.get())),
|
||||
BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
|
||||
};
|
||||
|
||||
TEST_F(PatternMatchTest, OneUse) {
|
||||
// Build up a little tree of values:
|
||||
//
|
||||
// One = (1 + 2) + 42
|
||||
// Two = One + 42
|
||||
// Leaf = (Two + 8) + (Two + 13)
|
||||
Value *One = IRB.CreateAdd(IRB.CreateAdd(IRB.getInt32(1), IRB.getInt32(2)),
|
||||
IRB.getInt32(42));
|
||||
Value *Two = IRB.CreateAdd(One, IRB.getInt32(42));
|
||||
Value *Leaf = IRB.CreateAdd(IRB.CreateAdd(Two, IRB.getInt32(8)),
|
||||
IRB.CreateAdd(Two, IRB.getInt32(13)));
|
||||
Value *V;
|
||||
|
||||
EXPECT_TRUE(m_OneUse(m_Value(V)).match(One));
|
||||
EXPECT_EQ(One, V);
|
||||
|
||||
EXPECT_FALSE(m_OneUse(m_Value()).match(Two));
|
||||
EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf));
|
||||
}
|
||||
|
||||
TEST_F(PatternMatchTest, FloatingPointOrderedMin) {
|
||||
Type *FltTy = IRB.getFloatTy();
|
||||
Value *L = ConstantFP::get(FltTy, 1.0);
|
||||
Value *R = ConstantFP::get(FltTy, 2.0);
|
||||
Value *MatchL, *MatchR;
|
||||
|
||||
// Test OLT.
|
||||
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test OLE.
|
||||
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test no match on OGE.
|
||||
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
|
||||
|
||||
// Test no match on OGT.
|
||||
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
|
||||
|
||||
// Test inverted selects. Note, that this "inverts" the ordering, e.g.:
|
||||
// %cmp = fcmp oge L, R
|
||||
// %min = select %cmp R, L
|
||||
// Given L == NaN
|
||||
// the above is expanded to %cmp == false ==> %min = L
|
||||
// which is true for UnordFMin, not OrdFMin, so test that:
|
||||
|
||||
// [OU]GE with inverted select.
|
||||
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
|
||||
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// [OU]GT with inverted select.
|
||||
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
|
||||
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
}
|
||||
|
||||
TEST_F(PatternMatchTest, FloatingPointOrderedMax) {
|
||||
Type *FltTy = IRB.getFloatTy();
|
||||
Value *L = ConstantFP::get(FltTy, 1.0);
|
||||
Value *R = ConstantFP::get(FltTy, 2.0);
|
||||
Value *MatchL, *MatchR;
|
||||
|
||||
// Test OGT.
|
||||
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test OGE.
|
||||
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test no match on OLE.
|
||||
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
|
||||
|
||||
// Test no match on OLT.
|
||||
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
|
||||
|
||||
|
||||
// Test inverted selects. Note, that this "inverts" the ordering, e.g.:
|
||||
// %cmp = fcmp ole L, R
|
||||
// %max = select %cmp, R, L
|
||||
// Given L == NaN,
|
||||
// the above is expanded to %cmp == false ==> %max == L
|
||||
// which is true for UnordFMax, not OrdFMax, so test that:
|
||||
|
||||
// [OU]LE with inverted select.
|
||||
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
|
||||
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// [OUT]LT with inverted select.
|
||||
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
|
||||
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
}
|
||||
|
||||
TEST_F(PatternMatchTest, FloatingPointUnorderedMin) {
|
||||
Type *FltTy = IRB.getFloatTy();
|
||||
Value *L = ConstantFP::get(FltTy, 1.0);
|
||||
Value *R = ConstantFP::get(FltTy, 2.0);
|
||||
Value *MatchL, *MatchR;
|
||||
|
||||
// Test ULT.
|
||||
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test ULE.
|
||||
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test no match on UGE.
|
||||
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
|
||||
|
||||
// Test no match on UGT.
|
||||
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
|
||||
|
||||
// Test inverted selects. Note, that this "inverts" the ordering, e.g.:
|
||||
// %cmp = fcmp uge L, R
|
||||
// %min = select %cmp R, L
|
||||
// Given L == NaN
|
||||
// the above is expanded to %cmp == true ==> %min = R
|
||||
// which is true for OrdFMin, not UnordFMin, so test that:
|
||||
|
||||
// [UO]GE with inverted select.
|
||||
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
|
||||
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// [UO]GT with inverted select.
|
||||
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
|
||||
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
}
|
||||
|
||||
TEST_F(PatternMatchTest, FloatingPointUnorderedMax) {
|
||||
Type *FltTy = IRB.getFloatTy();
|
||||
Value *L = ConstantFP::get(FltTy, 1.0);
|
||||
Value *R = ConstantFP::get(FltTy, 2.0);
|
||||
Value *MatchL, *MatchR;
|
||||
|
||||
// Test UGT.
|
||||
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test UGE.
|
||||
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// Test no match on ULE.
|
||||
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
|
||||
|
||||
// Test no match on ULT.
|
||||
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
|
||||
|
||||
// Test inverted selects. Note, that this "inverts" the ordering, e.g.:
|
||||
// %cmp = fcmp ule L, R
|
||||
// %max = select %cmp R, L
|
||||
// Given L == NaN
|
||||
// the above is expanded to %cmp == true ==> %max = R
|
||||
// which is true for OrdFMax, not UnordFMax, so test that:
|
||||
|
||||
// [UO]LE with inverted select.
|
||||
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
|
||||
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
// [UO]LT with inverted select.
|
||||
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
|
||||
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
|
||||
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
}
|
||||
|
||||
TEST_F(PatternMatchTest, OverflowingBinOps) {
|
||||
Value *L = IRB.getInt32(1);
|
||||
Value *R = IRB.getInt32(2);
|
||||
Value *MatchL, *MatchR;
|
||||
|
||||
EXPECT_TRUE(
|
||||
m_NSWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWAdd(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(
|
||||
m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(
|
||||
m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match(
|
||||
IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
EXPECT_TRUE(
|
||||
m_NUWAdd(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWAdd(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(
|
||||
m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(
|
||||
m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
MatchL = MatchR = nullptr;
|
||||
EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match(
|
||||
IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
|
||||
EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
|
||||
EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NSWAdd(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
|
||||
EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
|
||||
EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
|
||||
EXPECT_FALSE(m_NSWSub(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
|
||||
EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNUWMul(L, R)));
|
||||
EXPECT_FALSE(m_NSWMul(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
|
||||
EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(
|
||||
IRB.CreateShl(L, R, "", /* NUW */ true, /* NSW */ false)));
|
||||
EXPECT_FALSE(m_NSWShl(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
|
||||
|
||||
EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateAdd(L, R)));
|
||||
EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNSWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NUWAdd(m_Value(), m_Value()).match(IRB.CreateNUWSub(L, R)));
|
||||
EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateSub(L, R)));
|
||||
EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNSWSub(L, R)));
|
||||
EXPECT_FALSE(m_NUWSub(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateMul(L, R)));
|
||||
EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R)));
|
||||
EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
|
||||
EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
|
||||
EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(
|
||||
IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
|
||||
EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
|
||||
}
|
||||
|
||||
template <typename T> struct MutableConstTest : PatternMatchTest { };
|
||||
|
||||
typedef ::testing::Types<std::tuple<Value*, Instruction*>,
|
||||
std::tuple<const Value*, const Instruction *>>
|
||||
MutableConstTestTypes;
|
||||
TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);
|
||||
|
||||
TYPED_TEST(MutableConstTest, ICmp) {
|
||||
auto &IRB = PatternMatchTest::IRB;
|
||||
|
||||
typedef typename std::tuple_element<0, TypeParam>::type ValueType;
|
||||
typedef typename std::tuple_element<1, TypeParam>::type InstructionType;
|
||||
|
||||
Value *L = IRB.getInt32(1);
|
||||
Value *R = IRB.getInt32(2);
|
||||
ICmpInst::Predicate Pred = ICmpInst::ICMP_UGT;
|
||||
|
||||
ValueType MatchL;
|
||||
ValueType MatchR;
|
||||
ICmpInst::Predicate MatchPred;
|
||||
|
||||
EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
|
||||
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
|
||||
EXPECT_EQ(L, MatchL);
|
||||
EXPECT_EQ(R, MatchR);
|
||||
}
|
||||
|
||||
} // anonymous namespace.
|
||||
Reference in New Issue
Block a user