RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 04:02:41 +01:00
Code Issues Projects Releases Wiki Activity
f7e32458e4
llvm-mirror/unittests/IR/PatternMatch.cpp
Florian Hahn f7e32458e4 [PatternMatch] Add single index InsertValue matcher. 
This patch adds a new matcher for single index InsertValue instructions,
similar to the existing matcher for ExtractValue.

Reviewed By: lebedev.ri

Differential Revision: https://reviews.llvm.org/D91352
2020-11-12 21:27:18 +00:00

1633 lines
60 KiB
C++
Raw Blame History

//===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit 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/PatternMatch.h"
#include "llvm/ADT/APSInt.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, SpecificIntEQ) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntNE) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntUGT) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SignbitZeroChecks) {
Type *IntTy = IRB.getInt32Ty();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(m_Negative().match(NegOne));
EXPECT_FALSE(m_NonNegative().match(NegOne));
EXPECT_FALSE(m_StrictlyPositive().match(NegOne));
EXPECT_TRUE(m_NonPositive().match(NegOne));
EXPECT_FALSE(m_Negative().match(Zero));
EXPECT_TRUE(m_NonNegative().match(Zero));
EXPECT_FALSE(m_StrictlyPositive().match(Zero));
EXPECT_TRUE(m_NonPositive().match(Zero));
EXPECT_FALSE(m_Negative().match(One));
EXPECT_TRUE(m_NonNegative().match(One));
EXPECT_TRUE(m_StrictlyPositive().match(One));
EXPECT_FALSE(m_NonPositive().match(One));
}
TEST_F(PatternMatchTest, SpecificIntUGE) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntULT) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntULE) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSGT) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSGE) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSLT) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
.match(One));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSLE) {
Type *IntTy = IRB.getInt32Ty();
unsigned BitWidth = IntTy->getScalarSizeInBits();
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegOne = ConstantInt::get(IntTy, -1);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
.match(NegOne));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
.match(Zero));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
.match(NegOne));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
.match(Zero));
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
.match(One));
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
.match(NegOne));
}
TEST_F(PatternMatchTest, Unless) {
Value *X = IRB.CreateAdd(IRB.getInt32(1), IRB.getInt32(0));
EXPECT_TRUE(m_Add(m_One(), m_Zero()).match(X));
EXPECT_FALSE(m_Add(m_Zero(), m_One()).match(X));
EXPECT_FALSE(m_Unless(m_Add(m_One(), m_Zero())).match(X));
EXPECT_TRUE(m_Unless(m_Add(m_Zero(), m_One())).match(X));
EXPECT_TRUE(m_c_Add(m_One(), m_Zero()).match(X));
EXPECT_TRUE(m_c_Add(m_Zero(), m_One()).match(X));
EXPECT_FALSE(m_Unless(m_c_Add(m_One(), m_Zero())).match(X));
EXPECT_FALSE(m_Unless(m_c_Add(m_Zero(), m_One())).match(X));
}
TEST_F(PatternMatchTest, ZExtSExtSelf) {
LLVMContext &Ctx = IRB.getContext();
Value *One32 = IRB.getInt32(1);
Value *One64Z = IRB.CreateZExt(One32, IntegerType::getInt64Ty(Ctx));
Value *One64S = IRB.CreateSExt(One32, IntegerType::getInt64Ty(Ctx));
EXPECT_TRUE(m_One().match(One32));
EXPECT_FALSE(m_One().match(One64Z));
EXPECT_FALSE(m_One().match(One64S));
EXPECT_FALSE(m_ZExt(m_One()).match(One32));
EXPECT_TRUE(m_ZExt(m_One()).match(One64Z));
EXPECT_FALSE(m_ZExt(m_One()).match(One64S));
EXPECT_FALSE(m_SExt(m_One()).match(One32));
EXPECT_FALSE(m_SExt(m_One()).match(One64Z));
EXPECT_TRUE(m_SExt(m_One()).match(One64S));
EXPECT_TRUE(m_ZExtOrSelf(m_One()).match(One32));
EXPECT_TRUE(m_ZExtOrSelf(m_One()).match(One64Z));
EXPECT_FALSE(m_ZExtOrSelf(m_One()).match(One64S));
EXPECT_TRUE(m_SExtOrSelf(m_One()).match(One32));
EXPECT_FALSE(m_SExtOrSelf(m_One()).match(One64Z));
EXPECT_TRUE(m_SExtOrSelf(m_One()).match(One64S));
EXPECT_FALSE(m_ZExtOrSExt(m_One()).match(One32));
EXPECT_TRUE(m_ZExtOrSExt(m_One()).match(One64Z));
EXPECT_TRUE(m_ZExtOrSExt(m_One()).match(One64S));
EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One32));
EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One64Z));
EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One64S));
}
TEST_F(PatternMatchTest, Power2) {
Value *C128 = IRB.getInt32(128);
Value *CNeg128 = ConstantExpr::getNeg(cast<Constant>(C128));
EXPECT_TRUE(m_Power2().match(C128));
EXPECT_FALSE(m_Power2().match(CNeg128));
EXPECT_FALSE(m_NegatedPower2().match(C128));
EXPECT_TRUE(m_NegatedPower2().match(CNeg128));
Value *CIntMin = IRB.getInt64(APSInt::getSignedMinValue(64).getSExtValue());
Value *CNegIntMin = ConstantExpr::getNeg(cast<Constant>(CIntMin));
EXPECT_TRUE(m_Power2().match(CIntMin));
EXPECT_TRUE(m_Power2().match(CNegIntMin));
EXPECT_TRUE(m_NegatedPower2().match(CIntMin));
EXPECT_TRUE(m_NegatedPower2().match(CNegIntMin));
}
TEST_F(PatternMatchTest, CommutativeDeferredValue) {
Value *X = IRB.getInt32(1);
Value *Y = IRB.getInt32(2);
{
Value *tX = X;
EXPECT_TRUE(match(X, m_Deferred(tX)));
EXPECT_FALSE(match(Y, m_Deferred(tX)));
}
{
const Value *tX = X;
EXPECT_TRUE(match(X, m_Deferred(tX)));
EXPECT_FALSE(match(Y, m_Deferred(tX)));
}
{
Value *const tX = X;
EXPECT_TRUE(match(X, m_Deferred(tX)));
EXPECT_FALSE(match(Y, m_Deferred(tX)));
}
{
const Value *const tX = X;
EXPECT_TRUE(match(X, m_Deferred(tX)));
EXPECT_FALSE(match(Y, m_Deferred(tX)));
}
{
Value *tX = nullptr;
EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX))));
EXPECT_EQ(tX, X);
}
{
Value *tX = nullptr;
EXPECT_FALSE(
match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX))));
}
auto checkMatch = [X, Y](Value *Pattern) {
Value *tX = nullptr, *tY = nullptr;
EXPECT_TRUE(match(
Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY)))));
EXPECT_EQ(tX, X);
EXPECT_EQ(tY, Y);
};
checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y)));
checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X)));
checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X));
checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X));
}
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)));
}
TEST_F(PatternMatchTest, LoadStoreOps) {
// Create this load/store sequence:
//
// %p = alloca i32*
// %0 = load i32*, i32** %p
// store i32 42, i32* %0
Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty());
Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca);
Value *FourtyTwo = IRB.getInt32(42);
Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca);
Value *MatchLoad, *MatchStoreVal, *MatchStorePointer;
EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst));
EXPECT_EQ(Alloca, MatchLoad);
EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst));
EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca));
EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
.match(StoreInst));
EXPECT_EQ(FourtyTwo, MatchStoreVal);
EXPECT_EQ(Alloca, MatchStorePointer);
EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
.match(Alloca));
EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca))
.match(StoreInst));
EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo))
.match(StoreInst));
EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca))
.match(StoreInst));
}
TEST_F(PatternMatchTest, VectorOps) {
// Build up small tree of vector operations
//
// Val = 0 + 1
// Val2 = Val + 3
// VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef>
// VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4>
// VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4>
// VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2>
//
// SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer
// SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2>
// SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer
// SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer
//
// SP1 = VectorSplat(2, i8 2)
// SP2 = VectorSplat(2, i8 %Val)
Type *VecTy = FixedVectorType::get(IRB.getInt8Ty(), 2);
Type *i32 = IRB.getInt32Ty();
Type *i32VecTy = FixedVectorType::get(i32, 2);
Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1));
Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3));
SmallVector<Constant *, 2> VecElemIdxs;
VecElemIdxs.push_back(ConstantInt::get(i32, 0));
VecElemIdxs.push_back(ConstantInt::get(i32, 2));
auto *IdxVec = ConstantVector::get(VecElemIdxs);
Value *UndefVec = UndefValue::get(VecTy);
Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0);
Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val);
Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1);
Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val);
Value *EX1 = IRB.CreateExtractElement(VI4, Val);
Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0);
Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1);
Value *Zero = ConstantAggregateZero::get(i32VecTy);
Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero);
Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec);
Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero);
Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero);
Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2));
Value *SP2 = IRB.CreateVectorSplat(2, Val);
Value *A = nullptr, *B = nullptr, *C = nullptr;
// Test matching insertelement
EXPECT_TRUE(match(VI1, m_InsertElt(m_Value(), m_Value(), m_Value())));
EXPECT_TRUE(
match(VI1, m_InsertElt(m_Undef(), m_ConstantInt(), m_ConstantInt())));
EXPECT_TRUE(
match(VI1, m_InsertElt(m_Undef(), m_ConstantInt(), m_Zero())));
EXPECT_TRUE(
match(VI1, m_InsertElt(m_Undef(), m_SpecificInt(1), m_Zero())));
EXPECT_TRUE(match(VI2, m_InsertElt(m_Value(), m_Value(), m_Value())));
EXPECT_FALSE(
match(VI2, m_InsertElt(m_Value(), m_Value(), m_ConstantInt())));
EXPECT_FALSE(
match(VI2, m_InsertElt(m_Value(), m_ConstantInt(), m_Value())));
EXPECT_FALSE(match(VI2, m_InsertElt(m_Constant(), m_Value(), m_Value())));
EXPECT_TRUE(match(VI3, m_InsertElt(m_Value(A), m_Value(B), m_Value(C))));
EXPECT_TRUE(A == VI1);
EXPECT_TRUE(B == Val2);
EXPECT_TRUE(isa<ConstantInt>(C));
A = B = C = nullptr; // reset
// Test matching extractelement
EXPECT_TRUE(match(EX1, m_ExtractElt(m_Value(A), m_Value(B))));
EXPECT_TRUE(A == VI4);
EXPECT_TRUE(B == Val);
A = B = C = nullptr; // reset
EXPECT_FALSE(match(EX1, m_ExtractElt(m_Value(), m_ConstantInt())));
EXPECT_TRUE(match(EX2, m_ExtractElt(m_Value(), m_ConstantInt())));
EXPECT_TRUE(match(EX3, m_ExtractElt(m_Constant(), m_ConstantInt())));
// Test matching shufflevector
ArrayRef<int> Mask;
EXPECT_TRUE(match(SI1, m_Shuffle(m_Value(), m_Undef(), m_ZeroMask())));
EXPECT_TRUE(match(SI2, m_Shuffle(m_Value(A), m_Value(B), m_Mask(Mask))));
EXPECT_TRUE(A == VI3);
EXPECT_TRUE(B == VI4);
A = B = C = nullptr; // reset
// Test matching the vector splat pattern
EXPECT_TRUE(match(
SI1,
m_Shuffle(m_InsertElt(m_Undef(), m_SpecificInt(1), m_Zero()),
m_Undef(), m_ZeroMask())));
EXPECT_FALSE(match(
SI3, m_Shuffle(m_InsertElt(m_Undef(), m_Value(), m_Zero()),
m_Undef(), m_ZeroMask())));
EXPECT_FALSE(match(
SI4, m_Shuffle(m_InsertElt(m_Undef(), m_Value(), m_Zero()),
m_Undef(), m_ZeroMask())));
EXPECT_TRUE(match(
SP1,
m_Shuffle(m_InsertElt(m_Undef(), m_SpecificInt(2), m_Zero()),
m_Undef(), m_ZeroMask())));
EXPECT_TRUE(match(
SP2, m_Shuffle(m_InsertElt(m_Undef(), m_Value(A), m_Zero()),
m_Undef(), m_ZeroMask())));
EXPECT_TRUE(A == Val);
}
TEST_F(PatternMatchTest, VectorUndefInt) {
Type *ScalarTy = IRB.getInt8Ty();
Type *VectorTy = FixedVectorType::get(ScalarTy, 4);
Constant *ScalarUndef = UndefValue::get(ScalarTy);
Constant *VectorUndef = UndefValue::get(VectorTy);
Constant *ScalarZero = Constant::getNullValue(ScalarTy);
Constant *VectorZero = Constant::getNullValue(VectorTy);
SmallVector<Constant *, 4> Elems;
Elems.push_back(ScalarUndef);
Elems.push_back(ScalarZero);
Elems.push_back(ScalarUndef);
Elems.push_back(ScalarZero);
Constant *VectorZeroUndef = ConstantVector::get(Elems);
EXPECT_TRUE(match(ScalarUndef, m_Undef()));
EXPECT_TRUE(match(VectorUndef, m_Undef()));
EXPECT_FALSE(match(ScalarZero, m_Undef()));
EXPECT_FALSE(match(VectorZero, m_Undef()));
EXPECT_FALSE(match(VectorZeroUndef, m_Undef()));
EXPECT_FALSE(match(ScalarUndef, m_Zero()));
EXPECT_FALSE(match(VectorUndef, m_Zero()));
EXPECT_TRUE(match(ScalarZero, m_Zero()));
EXPECT_TRUE(match(VectorZero, m_Zero()));
EXPECT_TRUE(match(VectorZeroUndef, m_Zero()));
const APInt *C;
// Regardless of whether undefs are allowed,
// a fully undef constant does not match.
EXPECT_FALSE(match(ScalarUndef, m_APInt(C)));
EXPECT_FALSE(match(ScalarUndef, m_APIntForbidUndef(C)));
EXPECT_FALSE(match(ScalarUndef, m_APIntAllowUndef(C)));
EXPECT_FALSE(match(VectorUndef, m_APInt(C)));
EXPECT_FALSE(match(VectorUndef, m_APIntForbidUndef(C)));
EXPECT_FALSE(match(VectorUndef, m_APIntAllowUndef(C)));
// We can always match simple constants and simple splats.
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APInt(C)));
EXPECT_TRUE(C->isNullValue());
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APIntForbidUndef(C)));
EXPECT_TRUE(C->isNullValue());
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APIntAllowUndef(C)));
EXPECT_TRUE(C->isNullValue());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APInt(C)));
EXPECT_TRUE(C->isNullValue());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APIntForbidUndef(C)));
EXPECT_TRUE(C->isNullValue());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APIntAllowUndef(C)));
EXPECT_TRUE(C->isNullValue());
// Whether splats with undef can be matched depends on the matcher.
EXPECT_FALSE(match(VectorZeroUndef, m_APInt(C)));
EXPECT_FALSE(match(VectorZeroUndef, m_APIntForbidUndef(C)));
C = nullptr;
EXPECT_TRUE(match(VectorZeroUndef, m_APIntAllowUndef(C)));
EXPECT_TRUE(C->isNullValue());
}
TEST_F(PatternMatchTest, VectorUndefFloat) {
Type *ScalarTy = IRB.getFloatTy();
Type *VectorTy = FixedVectorType::get(ScalarTy, 4);
Constant *ScalarUndef = UndefValue::get(ScalarTy);
Constant *VectorUndef = UndefValue::get(VectorTy);
Constant *ScalarZero = Constant::getNullValue(ScalarTy);
Constant *VectorZero = Constant::getNullValue(VectorTy);
Constant *ScalarPosInf = ConstantFP::getInfinity(ScalarTy, false);
Constant *ScalarNegInf = ConstantFP::getInfinity(ScalarTy, true);
Constant *ScalarNaN = ConstantFP::getNaN(ScalarTy, true);
Constant *VectorZeroUndef =
ConstantVector::get({ScalarUndef, ScalarZero, ScalarUndef, ScalarZero});
Constant *VectorInfUndef = ConstantVector::get(
{ScalarPosInf, ScalarNegInf, ScalarUndef, ScalarPosInf});
Constant *VectorNaNUndef =
ConstantVector::get({ScalarUndef, ScalarNaN, ScalarNaN, ScalarNaN});
EXPECT_TRUE(match(ScalarUndef, m_Undef()));
EXPECT_TRUE(match(VectorUndef, m_Undef()));
EXPECT_FALSE(match(ScalarZero, m_Undef()));
EXPECT_FALSE(match(VectorZero, m_Undef()));
EXPECT_FALSE(match(VectorZeroUndef, m_Undef()));
EXPECT_FALSE(match(VectorInfUndef, m_Undef()));
EXPECT_FALSE(match(VectorNaNUndef, m_Undef()));
EXPECT_FALSE(match(ScalarUndef, m_AnyZeroFP()));
EXPECT_FALSE(match(VectorUndef, m_AnyZeroFP()));
EXPECT_TRUE(match(ScalarZero, m_AnyZeroFP()));
EXPECT_TRUE(match(VectorZero, m_AnyZeroFP()));
EXPECT_TRUE(match(VectorZeroUndef, m_AnyZeroFP()));
EXPECT_FALSE(match(VectorInfUndef, m_AnyZeroFP()));
EXPECT_FALSE(match(VectorNaNUndef, m_AnyZeroFP()));
EXPECT_FALSE(match(ScalarUndef, m_NaN()));
EXPECT_FALSE(match(VectorUndef, m_NaN()));
EXPECT_FALSE(match(VectorZeroUndef, m_NaN()));
EXPECT_FALSE(match(ScalarPosInf, m_NaN()));
EXPECT_FALSE(match(ScalarNegInf, m_NaN()));
EXPECT_TRUE(match(ScalarNaN, m_NaN()));
EXPECT_FALSE(match(VectorInfUndef, m_NaN()));
EXPECT_TRUE(match(VectorNaNUndef, m_NaN()));
EXPECT_FALSE(match(ScalarUndef, m_NonNaN()));
EXPECT_FALSE(match(VectorUndef, m_NonNaN()));
EXPECT_TRUE(match(VectorZeroUndef, m_NonNaN()));
EXPECT_TRUE(match(ScalarPosInf, m_NonNaN()));
EXPECT_TRUE(match(ScalarNegInf, m_NonNaN()));
EXPECT_FALSE(match(ScalarNaN, m_NonNaN()));
EXPECT_TRUE(match(VectorInfUndef, m_NonNaN()));
EXPECT_FALSE(match(VectorNaNUndef, m_NonNaN()));
EXPECT_FALSE(match(ScalarUndef, m_Inf()));
EXPECT_FALSE(match(VectorUndef, m_Inf()));
EXPECT_FALSE(match(VectorZeroUndef, m_Inf()));
EXPECT_TRUE(match(ScalarPosInf, m_Inf()));
EXPECT_TRUE(match(ScalarNegInf, m_Inf()));
EXPECT_FALSE(match(ScalarNaN, m_Inf()));
EXPECT_TRUE(match(VectorInfUndef, m_Inf()));
EXPECT_FALSE(match(VectorNaNUndef, m_Inf()));
EXPECT_FALSE(match(ScalarUndef, m_NonInf()));
EXPECT_FALSE(match(VectorUndef, m_NonInf()));
EXPECT_TRUE(match(VectorZeroUndef, m_NonInf()));
EXPECT_FALSE(match(ScalarPosInf, m_NonInf()));
EXPECT_FALSE(match(ScalarNegInf, m_NonInf()));
EXPECT_TRUE(match(ScalarNaN, m_NonInf()));
EXPECT_FALSE(match(VectorInfUndef, m_NonInf()));
EXPECT_TRUE(match(VectorNaNUndef, m_NonInf()));
EXPECT_FALSE(match(ScalarUndef, m_Finite()));
EXPECT_FALSE(match(VectorUndef, m_Finite()));
EXPECT_TRUE(match(VectorZeroUndef, m_Finite()));
EXPECT_FALSE(match(ScalarPosInf, m_Finite()));
EXPECT_FALSE(match(ScalarNegInf, m_Finite()));
EXPECT_FALSE(match(ScalarNaN, m_Finite()));
EXPECT_FALSE(match(VectorInfUndef, m_Finite()));
EXPECT_FALSE(match(VectorNaNUndef, m_Finite()));
const APFloat *C;
// Regardless of whether undefs are allowed,
// a fully undef constant does not match.
EXPECT_FALSE(match(ScalarUndef, m_APFloat(C)));
EXPECT_FALSE(match(ScalarUndef, m_APFloatForbidUndef(C)));
EXPECT_FALSE(match(ScalarUndef, m_APFloatAllowUndef(C)));
EXPECT_FALSE(match(VectorUndef, m_APFloat(C)));
EXPECT_FALSE(match(VectorUndef, m_APFloatForbidUndef(C)));
EXPECT_FALSE(match(VectorUndef, m_APFloatAllowUndef(C)));
// We can always match simple constants and simple splats.
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APFloat(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APFloatForbidUndef(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(ScalarZero, m_APFloatAllowUndef(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APFloat(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APFloatForbidUndef(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(VectorZero, m_APFloatAllowUndef(C)));
EXPECT_TRUE(C->isZero());
// Whether splats with undef can be matched depends on the matcher.
EXPECT_FALSE(match(VectorZeroUndef, m_APFloat(C)));
EXPECT_FALSE(match(VectorZeroUndef, m_APFloatForbidUndef(C)));
C = nullptr;
EXPECT_TRUE(match(VectorZeroUndef, m_APFloatAllowUndef(C)));
EXPECT_TRUE(C->isZero());
C = nullptr;
EXPECT_TRUE(match(VectorZeroUndef, m_Finite(C)));
EXPECT_TRUE(C->isZero());
}
TEST_F(PatternMatchTest, FloatingPointFNeg) {
Type *FltTy = IRB.getFloatTy();
Value *One = ConstantFP::get(FltTy, 1.0);
Value *Z = ConstantFP::get(FltTy, 0.0);
Value *NZ = ConstantFP::get(FltTy, -0.0);
Value *V = IRB.CreateFNeg(One);
Value *V1 = IRB.CreateFSub(NZ, One);
Value *V2 = IRB.CreateFSub(Z, One);
Value *V3 = IRB.CreateFAdd(NZ, One);
Value *Match;
// Test FNeg(1.0)
EXPECT_TRUE(match(V, m_FNeg(m_Value(Match))));
EXPECT_EQ(One, Match);
// Test FSub(-0.0, 1.0)
EXPECT_TRUE(match(V1, m_FNeg(m_Value(Match))));
EXPECT_EQ(One, Match);
// Test FSub(0.0, 1.0)
EXPECT_FALSE(match(V2, m_FNeg(m_Value(Match))));
cast<Instruction>(V2)->setHasNoSignedZeros(true);
EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match))));
EXPECT_EQ(One, Match);
// Test FAdd(-0.0, 1.0)
EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match))));
}
TEST_F(PatternMatchTest, CondBranchTest) {
BasicBlock *TrueBB = BasicBlock::Create(Ctx, "TrueBB", F);
BasicBlock *FalseBB = BasicBlock::Create(Ctx, "FalseBB", F);
Value *Br1 = IRB.CreateCondBr(IRB.getTrue(), TrueBB, FalseBB);
EXPECT_TRUE(match(Br1, m_Br(m_Value(), m_BasicBlock(), m_BasicBlock())));
BasicBlock *A, *B;
EXPECT_TRUE(match(Br1, m_Br(m_Value(), m_BasicBlock(A), m_BasicBlock(B))));
EXPECT_EQ(TrueBB, A);
EXPECT_EQ(FalseBB, B);
EXPECT_FALSE(
match(Br1, m_Br(m_Value(), m_SpecificBB(FalseBB), m_BasicBlock())));
EXPECT_FALSE(
match(Br1, m_Br(m_Value(), m_BasicBlock(), m_SpecificBB(TrueBB))));
EXPECT_FALSE(
match(Br1, m_Br(m_Value(), m_SpecificBB(FalseBB), m_BasicBlock(TrueBB))));
EXPECT_TRUE(
match(Br1, m_Br(m_Value(), m_SpecificBB(TrueBB), m_BasicBlock(FalseBB))));
// Check we can use m_Deferred with branches.
EXPECT_FALSE(match(Br1, m_Br(m_Value(), m_BasicBlock(A), m_Deferred(A))));
Value *Br2 = IRB.CreateCondBr(IRB.getTrue(), TrueBB, TrueBB);
A = nullptr;
EXPECT_TRUE(match(Br2, m_Br(m_Value(), m_BasicBlock(A), m_Deferred(A))));
}
TEST_F(PatternMatchTest, WithOverflowInst) {
Value *Add = IRB.CreateBinaryIntrinsic(Intrinsic::uadd_with_overflow,
IRB.getInt32(0), IRB.getInt32(0));
Value *Add0 = IRB.CreateExtractValue(Add, 0);
Value *Add1 = IRB.CreateExtractValue(Add, 1);
EXPECT_TRUE(match(Add0, m_ExtractValue<0>(m_Value())));
EXPECT_FALSE(match(Add0, m_ExtractValue<1>(m_Value())));
EXPECT_FALSE(match(Add1, m_ExtractValue<0>(m_Value())));
EXPECT_TRUE(match(Add1, m_ExtractValue<1>(m_Value())));
EXPECT_FALSE(match(Add, m_ExtractValue<1>(m_Value())));
EXPECT_FALSE(match(Add, m_ExtractValue<1>(m_Value())));
WithOverflowInst *WOI;
EXPECT_FALSE(match(Add0, m_WithOverflowInst(WOI)));
EXPECT_FALSE(match(Add1, m_WithOverflowInst(WOI)));
EXPECT_TRUE(match(Add, m_WithOverflowInst(WOI)));
EXPECT_TRUE(match(Add0, m_ExtractValue<0>(m_WithOverflowInst(WOI))));
EXPECT_EQ(Add, WOI);
EXPECT_TRUE(match(Add1, m_ExtractValue<1>(m_WithOverflowInst(WOI))));
EXPECT_EQ(Add, WOI);
}
TEST_F(PatternMatchTest, MinMaxIntrinsics) {
Type *Ty = IRB.getInt32Ty();
Value *L = ConstantInt::get(Ty, 1);
Value *R = ConstantInt::get(Ty, 2);
Value *MatchL, *MatchR;
// Check for intrinsic ID match and capture of operands.
EXPECT_TRUE(m_SMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::smax, L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
EXPECT_TRUE(m_SMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::smin, L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
EXPECT_TRUE(m_UMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::umax, L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
EXPECT_TRUE(m_UMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::umin, L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
// Check for intrinsic ID mismatch.
EXPECT_FALSE(m_SMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::smin, L, R)));
EXPECT_FALSE(m_SMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::umax, L, R)));
EXPECT_FALSE(m_UMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::umin, L, R)));
EXPECT_FALSE(m_UMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateBinaryIntrinsic(Intrinsic::smax, L, R)));
}
TEST_F(PatternMatchTest, IntrinsicMatcher) {
Value *Name = IRB.CreateAlloca(IRB.getInt8Ty());
Value *Hash = IRB.getInt64(0);
Value *Num = IRB.getInt32(1);
Value *Index = IRB.getInt32(2);
Value *Step = IRB.getInt64(3);
Value *Ops[] = {Name, Hash, Num, Index, Step};
Module *M = BB->getParent()->getParent();
Function *TheFn =
Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment_step);
Value *Intrinsic5 = CallInst::Create(TheFn, Ops, "", BB);
// Match without capturing.
EXPECT_TRUE(match(
Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_Value(), m_Value(), m_Value())));
EXPECT_FALSE(match(
Intrinsic5, m_Intrinsic<Intrinsic::memmove>(
m_Value(), m_Value(), m_Value(), m_Value(), m_Value())));
// Match with capturing.
Value *Arg1 = nullptr;
Value *Arg2 = nullptr;
Value *Arg3 = nullptr;
Value *Arg4 = nullptr;
Value *Arg5 = nullptr;
EXPECT_TRUE(
match(Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(Arg1), m_Value(Arg2), m_Value(Arg3),
m_Value(Arg4), m_Value(Arg5))));
EXPECT_EQ(Arg1, Name);
EXPECT_EQ(Arg2, Hash);
EXPECT_EQ(Arg3, Num);
EXPECT_EQ(Arg4, Index);
EXPECT_EQ(Arg5, Step);
// Match specific second argument.
EXPECT_TRUE(
match(Intrinsic5,
m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_SpecificInt(0), m_Value(), m_Value(), m_Value())));
EXPECT_FALSE(
match(Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_SpecificInt(10), m_Value(), m_Value(),
m_Value())));
// Match specific third argument.
EXPECT_TRUE(
match(Intrinsic5,
m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_SpecificInt(1), m_Value(), m_Value())));
EXPECT_FALSE(
match(Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_SpecificInt(10), m_Value(),
m_Value())));
// Match specific fourth argument.
EXPECT_TRUE(
match(Intrinsic5,
m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_Value(), m_SpecificInt(2), m_Value())));
EXPECT_FALSE(
match(Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_Value(), m_SpecificInt(10),
m_Value())));
// Match specific fifth argument.
EXPECT_TRUE(
match(Intrinsic5,
m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_Value(), m_Value(), m_SpecificInt(3))));
EXPECT_FALSE(
match(Intrinsic5, m_Intrinsic<Intrinsic::instrprof_increment_step>(
m_Value(), m_Value(), m_Value(), m_Value(),
m_SpecificInt(10))));
}
namespace {
struct is_unsigned_zero_pred {
bool isValue(const APInt &C) { return C.isNullValue(); }
};
struct is_float_zero_pred {
bool isValue(const APFloat &C) { return C.isZero(); }
};
template <typename T> struct always_true_pred {
bool isValue(const T &) { return true; }
};
template <typename T> struct always_false_pred {
bool isValue(const T &) { return false; }
};
struct is_unsigned_max_pred {
bool isValue(const APInt &C) { return C.isMaxValue(); }
};
struct is_float_nan_pred {
bool isValue(const APFloat &C) { return C.isNaN(); }
};
} // namespace
TEST_F(PatternMatchTest, ConstantPredicateType) {
// Scalar integer
APInt U32Max = APInt::getAllOnesValue(32);
APInt U32Zero = APInt::getNullValue(32);
APInt U32DeadBeef(32, 0xDEADBEEF);
Type *U32Ty = Type::getInt32Ty(Ctx);
Constant *CU32Max = Constant::getIntegerValue(U32Ty, U32Max);
Constant *CU32Zero = Constant::getIntegerValue(U32Ty, U32Zero);
Constant *CU32DeadBeef = Constant::getIntegerValue(U32Ty, U32DeadBeef);
EXPECT_TRUE(match(CU32Max, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(match(CU32Max, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CU32Max, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CU32Max, cst_pred_ty<always_false_pred<APInt>>()));
EXPECT_FALSE(match(CU32Zero, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_TRUE(match(CU32Zero, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CU32Zero, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CU32Zero, cst_pred_ty<always_false_pred<APInt>>()));
EXPECT_FALSE(match(CU32DeadBeef, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(match(CU32DeadBeef, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CU32DeadBeef, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CU32DeadBeef, cst_pred_ty<always_false_pred<APInt>>()));
// Scalar float
APFloat F32NaN = APFloat::getNaN(APFloat::IEEEsingle());
APFloat F32Zero = APFloat::getZero(APFloat::IEEEsingle());
APFloat F32Pi(3.14f);
Type *F32Ty = Type::getFloatTy(Ctx);
Constant *CF32NaN = ConstantFP::get(F32Ty, F32NaN);
Constant *CF32Zero = ConstantFP::get(F32Ty, F32Zero);
Constant *CF32Pi = ConstantFP::get(F32Ty, F32Pi);
EXPECT_TRUE(match(CF32NaN, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CF32NaN, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(match(CF32NaN, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(match(CF32NaN, cstfp_pred_ty<always_false_pred<APFloat>>()));
EXPECT_FALSE(match(CF32Zero, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_TRUE(match(CF32Zero, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(match(CF32Zero, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(match(CF32Zero, cstfp_pred_ty<always_false_pred<APFloat>>()));
EXPECT_FALSE(match(CF32Pi, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CF32Pi, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(match(CF32Pi, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(match(CF32Pi, cstfp_pred_ty<always_false_pred<APFloat>>()));
auto FixedEC = ElementCount::getFixed(4);
auto ScalableEC = ElementCount::getScalable(4);
// Vector splat
for (auto EC : {FixedEC, ScalableEC}) {
// integer
Constant *CSplatU32Max = ConstantVector::getSplat(EC, CU32Max);
Constant *CSplatU32Zero = ConstantVector::getSplat(EC, CU32Zero);
Constant *CSplatU32DeadBeef = ConstantVector::getSplat(EC, CU32DeadBeef);
EXPECT_TRUE(match(CSplatU32Max, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(match(CSplatU32Max, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CSplatU32Max, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CSplatU32Max, cst_pred_ty<always_false_pred<APInt>>()));
EXPECT_FALSE(match(CSplatU32Zero, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_TRUE(match(CSplatU32Zero, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CSplatU32Zero, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CSplatU32Zero, cst_pred_ty<always_false_pred<APInt>>()));
EXPECT_FALSE(match(CSplatU32DeadBeef, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(
match(CSplatU32DeadBeef, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(
match(CSplatU32DeadBeef, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(
match(CSplatU32DeadBeef, cst_pred_ty<always_false_pred<APInt>>()));
// float
Constant *CSplatF32NaN = ConstantVector::getSplat(EC, CF32NaN);
Constant *CSplatF32Zero = ConstantVector::getSplat(EC, CF32Zero);
Constant *CSplatF32Pi = ConstantVector::getSplat(EC, CF32Pi);
EXPECT_TRUE(match(CSplatF32NaN, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CSplatF32NaN, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(
match(CSplatF32NaN, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(
match(CSplatF32NaN, cstfp_pred_ty<always_false_pred<APFloat>>()));
EXPECT_FALSE(match(CSplatF32Zero, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_TRUE(match(CSplatF32Zero, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(
match(CSplatF32Zero, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(
match(CSplatF32Zero, cstfp_pred_ty<always_false_pred<APFloat>>()));
EXPECT_FALSE(match(CSplatF32Pi, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CSplatF32Pi, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(match(CSplatF32Pi, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(
match(CSplatF32Pi, cstfp_pred_ty<always_false_pred<APFloat>>()));
}
// Int arbitrary vector
Constant *CMixedU32 = ConstantVector::get({CU32Max, CU32Zero, CU32DeadBeef});
Constant *CU32Undef = UndefValue::get(U32Ty);
Constant *CU32MaxWithUndef =
ConstantVector::get({CU32Undef, CU32Max, CU32Undef});
EXPECT_FALSE(match(CMixedU32, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(match(CMixedU32, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CMixedU32, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(match(CMixedU32, cst_pred_ty<always_false_pred<APInt>>()));
EXPECT_TRUE(match(CU32MaxWithUndef, cst_pred_ty<is_unsigned_max_pred>()));
EXPECT_FALSE(match(CU32MaxWithUndef, cst_pred_ty<is_unsigned_zero_pred>()));
EXPECT_TRUE(match(CU32MaxWithUndef, cst_pred_ty<always_true_pred<APInt>>()));
EXPECT_FALSE(
match(CU32MaxWithUndef, cst_pred_ty<always_false_pred<APInt>>()));
// Float arbitrary vector
Constant *CMixedF32 = ConstantVector::get({CF32NaN, CF32Zero, CF32Pi});
Constant *CF32Undef = UndefValue::get(F32Ty);
Constant *CF32NaNWithUndef =
ConstantVector::get({CF32Undef, CF32NaN, CF32Undef});
EXPECT_FALSE(match(CMixedF32, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CMixedF32, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(match(CMixedF32, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(match(CMixedF32, cstfp_pred_ty<always_false_pred<APFloat>>()));
EXPECT_TRUE(match(CF32NaNWithUndef, cstfp_pred_ty<is_float_nan_pred>()));
EXPECT_FALSE(match(CF32NaNWithUndef, cstfp_pred_ty<is_float_zero_pred>()));
EXPECT_TRUE(
match(CF32NaNWithUndef, cstfp_pred_ty<always_true_pred<APFloat>>()));
EXPECT_FALSE(
match(CF32NaNWithUndef, cstfp_pred_ty<always_false_pred<APFloat>>()));
}
TEST_F(PatternMatchTest, InsertValue) {
Type *StructTy = StructType::create(IRB.getContext(),
{IRB.getInt32Ty(), IRB.getInt64Ty()});
Value *Ins0 =
IRB.CreateInsertValue(UndefValue::get(StructTy), IRB.getInt32(20), 0);
Value *Ins1 = IRB.CreateInsertValue(Ins0, IRB.getInt64(90), 1);
EXPECT_TRUE(match(Ins0, m_InsertValue<0>(m_Value(), m_Value())));
EXPECT_FALSE(match(Ins0, m_InsertValue<1>(m_Value(), m_Value())));
EXPECT_FALSE(match(Ins1, m_InsertValue<0>(m_Value(), m_Value())));
EXPECT_TRUE(match(Ins1, m_InsertValue<1>(m_Value(), m_Value())));
EXPECT_TRUE(match(Ins0, m_InsertValue<0>(m_Undef(), m_SpecificInt(20))));
EXPECT_FALSE(match(Ins0, m_InsertValue<0>(m_Undef(), m_SpecificInt(0))));
EXPECT_TRUE(
match(Ins1, m_InsertValue<1>(m_InsertValue<0>(m_Value(), m_Value()),
m_SpecificInt(90))));
EXPECT_FALSE(match(IRB.getInt64(99), m_InsertValue<0>(m_Value(), m_Value())));
}
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 std::tuple_element_t<0, TypeParam> ValueType;
typedef std::tuple_element_t<1, TypeParam> 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 View Git Blame Copy Permalink