maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/unittests/IR/PatternMatch.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1266 lines
45 KiB
C++
Raw Normal View History

PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
//===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// 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
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
//
//===----------------------------------------------------------------------===//
Re-sort #include lines for unittests. This uses a slightly modified clang-format (https://reviews.llvm.org/D33932) to keep primary headers at the top and handle new utility headers like 'gmock' consistently with other utility headers. No other change was made. I did no manual edits, all of this is clang-format. This should allow other changes to have more clear and focused diffs, and is especially motivated by moving some headers into more focused libraries. llvm-svn: 304786
2017-06-06 19:06:56 +08:00
#include "llvm/IR/PatternMatch.h"
[IR][PatternMatch] Introduce m_NegatedPower2() matcher Summary: It is a good idea to do as much matching inside of `match()` as possible. If some checking is done afterwards, and we don't fold because of it, chances are we may have missed some commutative pattern. Reviewers: spatel, craig.topper, RKSimon Reviewed By: spatel, RKSimon Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64038 llvm-svn: 367017
2019-07-25 21:34:24 +08:00
#include "llvm/ADT/APSInt.h"
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
#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"
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
#include "llvm/IR/Function.h"
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
#include "llvm/IR/IRBuilder.h"
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
#include "llvm/IR/Instructions.h"
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/MDBuilder.h"
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
#include "llvm/IR/Module.h"
[Modules] Move the NoFolder into the IR library as it creates instructions. llvm-svn: 202834
2014-03-04 20:05:47 +08:00
#include "llvm/IR/NoFolder.h"
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
#include "llvm/IR/Operator.h"
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
#include "llvm/IR/Type.h"
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
#include "gtest/gtest.h"
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
using namespace llvm;
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
using namespace llvm::PatternMatch;
namespace {
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
struct PatternMatchTest : ::testing::Test {
LLVMContext Ctx;
Replace OwningPtr<T> with std::unique_ptr<T>. This compiles with no changes to clang/lld/lldb with MSVC and includes overloads to various functions which are used by those projects and llvm which have OwningPtr's as parameters. This should allow out of tree projects some time to move. There are also no changes to libs/Target, which should help out of tree targets have time to move, if necessary. llvm-svn: 203083
2014-03-06 13:51:42 +08:00
std::unique_ptr<Module> M;
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
Function *F;
BasicBlock *BB;
Remove PreserveNames template parameter from IRBuilder This reapplies r263258, which was reverted in r263321 because of issues on Clang side. From: Mehdi Amini <mehdi.amini@apple.com> llvm-svn: 263393
2016-03-14 05:05:13 +08:00
IRBuilder<NoFolder> IRB;
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
PatternMatchTest()
: M(new Module("PatternMatchTestModule", Ctx)),
F(Function::Create(
FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
Function::ExternalLinkage, "f", M.get())),
Revert "r366069: [PatternMatch] Implement matching code for LibFunc" Reason: the change introduced a layering violation by adding a dependency on IR to Analysis. llvm-svn: 366081
2019-07-16 00:43:36 +08:00
BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
};
Add in a unittest for the one-use pattern matcher. llvm-svn: 198552
2014-01-05 17:14:53 +08:00
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));
}
[PatternMatch] Generalize m_SpecificInt_ULT() to take ICmpInst::Predicate As discussed in the original review, this may be useful, so let's just do it. llvm-svn: 365652
2019-07-11 00:07:35 +08:00
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));
}
[APInt][PatternMatch] Add 'is non-positive' predicate It will be useful for implementing the fold mentioned in https://bugs.llvm.org/show_bug.cgi?id=44100#c4
2019-12-04 02:17:51 +08:00
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));
}
[PatternMatch] Generalize m_SpecificInt_ULT() to take ICmpInst::Predicate As discussed in the original review, this may be useful, so let's just do it. llvm-svn: 365652
2019-07-11 00:07:35 +08:00
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));
}
[IR][Patternmatch] Add m_SpecificInt_ULT() predicate Summary: Match an integer or vector with every element unsigned less than the Threshold. For vectors, this includes constants with undefined elements. FIXME: is it worth generalizing this to simply take ICmpInst::Predicate? Reviewers: craig.topper, spatel, nikic Reviewed By: spatel Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D63811 llvm-svn: 364711
2019-06-29 19:51:37 +08:00
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);
[PatternMatch] Generalize m_SpecificInt_ULT() to take ICmpInst::Predicate As discussed in the original review, this may be useful, so let's just do it. llvm-svn: 365652
2019-07-11 00:07:35 +08:00
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));
[IR][Patternmatch] Add m_SpecificInt_ULT() predicate Summary: Match an integer or vector with every element unsigned less than the Threshold. For vectors, this includes constants with undefined elements. FIXME: is it worth generalizing this to simply take ICmpInst::Predicate? Reviewers: craig.topper, spatel, nikic Reviewed By: spatel Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D63811 llvm-svn: 364711
2019-06-29 19:51:37 +08:00
[PatternMatch] Generalize m_SpecificInt_ULT() to take ICmpInst::Predicate As discussed in the original review, this may be useful, so let's just do it. llvm-svn: 365652
2019-07-11 00:07:35 +08:00
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));
[IR][Patternmatch] Add m_SpecificInt_ULT() predicate Summary: Match an integer or vector with every element unsigned less than the Threshold. For vectors, this includes constants with undefined elements. FIXME: is it worth generalizing this to simply take ICmpInst::Predicate? Reviewers: craig.topper, spatel, nikic Reviewed By: spatel Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D63811 llvm-svn: 364711
2019-06-29 19:51:37 +08:00
[PatternMatch] Generalize m_SpecificInt_ULT() to take ICmpInst::Predicate As discussed in the original review, this may be useful, so let's just do it. llvm-svn: 365652
2019-07-11 00:07:35 +08:00
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));
[IR][Patternmatch] Add m_SpecificInt_ULT() predicate Summary: Match an integer or vector with every element unsigned less than the Threshold. For vectors, this includes constants with undefined elements. FIXME: is it worth generalizing this to simply take ICmpInst::Predicate? Reviewers: craig.topper, spatel, nikic Reviewed By: spatel Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D63811 llvm-svn: 364711
2019-06-29 19:51:37 +08:00
}
[IR][PatternMatch] introduce m_Unless() matcher Summary: I don't think it already exists? I don't see it at least. It is important to have it because else we'll do some checks after `match()`, and that may result in missed folds in commutative nodes. Reviewers: spatel, craig.topper, RKSimon, majnemer Reviewed By: spatel Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64037 llvm-svn: 367016
2019-07-25 21:34:14 +08:00
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));
}
[PatternMatch] Add m_SExtOrSelf(), m_ZExtOrSExtOrSelf() matchers + unittests m_SExtOrSelf() is for consistency. m_ZExtOrSExtOrSelf() is motivated by the D68103/r373106 : sometimes it is useful to look past any extensions of the shift amount, and m_ZExtOrSExtOrSelf() may be exactly the tool to do that. llvm-svn: 373128
2019-09-28 05:53:04 +08:00
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));
}
[IR][PatternMatch] Introduce m_NegatedPower2() matcher Summary: It is a good idea to do as much matching inside of `match()` as possible. If some checking is done afterwards, and we don't fold because of it, chances are we may have missed some commutative pattern. Reviewers: spatel, craig.topper, RKSimon Reviewed By: spatel, RKSimon Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64038 llvm-svn: 367017
2019-07-25 21:34:24 +08:00
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));
}
[PatternMatch] Stabilize the matching order of commutative matchers Summary: Currently, we 1. match `LHS` matcher to the `first` operand of binary operator, 2. and then match `RHS` matcher to the `second` operand of binary operator. If that does not match, we swap the `LHS` and `RHS` matchers: 1. match `RHS` matcher to the `first` operand of binary operator, 2. and then match `LHS` matcher to the `second` operand of binary operator. This works ok. But it complicates writing of commutative matchers, where one would like to match (`m_Value()`) the value on one side, and use (`m_Specific()`) it on the other side. This is additionally complicated by the fact that `m_Specific()` stores the `Value *`, not `Value **`, so it won't work at all out of the box. The last problem is trivially solved by adding a new `m_c_Specific()` that stores the `Value **`, not `Value *`. I'm choosing to add a new matcher, not change the existing one because i guess all the current users are ok with existing behavior, and this additional pointer indirection may have performance drawbacks. Also, i'm storing pointer, not reference, because for some mysterious-to-me reason it did not work with the reference. The first one appears trivial, too. Currently, we 1. match `LHS` matcher to the `first` operand of binary operator, 2. and then match `RHS` matcher to the `second` operand of binary operator. If that does not match, we swap the ~~`LHS` and `RHS` matchers~~ **operands**: 1. match ~~`RHS`~~ **`LHS`** matcher to the ~~`first`~~ **`second`** operand of binary operator, 2. and then match ~~`LHS`~~ **`RHS`** matcher to the ~~`second`~ **`first`** operand of binary operator. Surprisingly, `$ ninja check-llvm` still passes with this. But i expect the bots will disagree.. The motivational unittest is included. I'd like to use this in D45664. Reviewers: spatel, craig.topper, arsenm, RKSimon Reviewed By: craig.topper Subscribers: xbolva00, wdng, llvm-commits Differential Revision: https://reviews.llvm.org/D45828 llvm-svn: 331085
2018-04-28 05:23:20 +08:00
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));
}
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
TEST_F(PatternMatchTest, FloatingPointOrderedMin) {
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
Type *FltTy = IRB.getFloatTy();
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Value *L = ConstantFP::get(FltTy, 1.0);
Value *R = ConstantFP::get(FltTy, 2.0);
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
Value *MatchL, *MatchR;
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test OLT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test OLE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on OGE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on OGT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// 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))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// [OU]GT with inverted select.
EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
}
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
TEST_F(PatternMatchTest, FloatingPointOrderedMax) {
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
Type *FltTy = IRB.getFloatTy();
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Value *L = ConstantFP::get(FltTy, 1.0);
Value *R = ConstantFP::get(FltTy, 2.0);
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
Value *MatchL, *MatchR;
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test OGT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test OGE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on OLE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on OLT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// 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)));
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// [OUT]LT with inverted select.
EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
}
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
TEST_F(PatternMatchTest, FloatingPointUnorderedMin) {
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
Type *FltTy = IRB.getFloatTy();
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Value *L = ConstantFP::get(FltTy, 1.0);
Value *R = ConstantFP::get(FltTy, 2.0);
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
Value *MatchL, *MatchR;
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test ULT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test ULE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on UGE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on UGT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// 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))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGE(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// [UO]GT with inverted select.
EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOGT(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
}
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
TEST_F(PatternMatchTest, FloatingPointUnorderedMax) {
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
Type *FltTy = IRB.getFloatTy();
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Value *L = ConstantFP::get(FltTy, 1.0);
Value *R = ConstantFP::get(FltTy, 2.0);
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
Value *MatchL, *MatchR;
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test UGT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGT(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test UGE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpUGE(L, R), L, R)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on ULE.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
// Test no match on ULT.
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), L, R)));
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// 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))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpULE(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLE(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
// [UO]LT with inverted select.
EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
Use a shorter name for the IRBuilder member. This will help the tests I'm adding next be a lot more readable. llvm-svn: 198534
2014-01-05 10:23:11 +08:00
.match(IRB.CreateSelect(IRB.CreateFCmpULT(L, R), R, L)));
Fix m_[Ord|Unord][FMin|FMax] matchers to correctly match ordering. Previously, the matching was done incorrectly for the case where operands for FCmpInst and SelectInst were in opposite order. Patch by Andrei Elovikov. Differential Revision: https://reviews.llvm.org/D33185 llvm-svn: 305308
2017-06-14 01:18:45 +08:00
EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
.match(IRB.CreateSelect(IRB.CreateFCmpOLT(L, R), R, L)));
Simplify the PatternMatch unittest by giving it a module, function, and basic block to hold instructions, and managing all of their lifetimes in a fixture. This makes it easy to sink the expectations into the test cases themselves which also makes things a bit more explicit and clearer IMO. llvm-svn: 198532
2014-01-05 10:07:20 +08:00
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
}
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
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);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
EXPECT_TRUE(
m_NSWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWSub(L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
EXPECT_TRUE(
m_NSWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNSWMul(L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
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);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
EXPECT_TRUE(
m_NUWSub(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWSub(L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
EXPECT_TRUE(
m_NUWMul(m_Value(MatchL), m_Value(MatchR)).match(IRB.CreateNUWMul(L, R)));
EXPECT_EQ(L, MatchL);
EXPECT_EQ(R, MatchR);
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08:00
MatchL = MatchR = nullptr;
Add support to the pattern match library for matching NSW and NUW instructions. I needed this for a quick experiment I was making, and while I've no idea if that will ever get committed, I didn't want to throw away the pattern match code and for anyone else to have to write it again. I've added unittests to make sure this works correctly. In fun news, this also uncovered the IRBuilder bug. Doh! llvm-svn: 198541
2014-01-05 11:28:29 +08:00
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)));
}
[PatternMatch] Add m_Store pattern match helper Differential Revision: https://reviews.llvm.org/D48279 llvm-svn: 335100
2018-06-20 15:27:45 +08:00
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());
[opaque pointer types] Pass value type to LoadInst creation. This cleans up all LoadInst creation in LLVM to explicitly pass the value type rather than deriving it from the pointer's element-type. Differential Revision: https://reviews.llvm.org/D57172 llvm-svn: 352911
2019-02-02 04:44:24 +08:00
Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca);
[PatternMatch] Add m_Store pattern match helper Differential Revision: https://reviews.llvm.org/D48279 llvm-svn: 335100
2018-06-20 15:27:45 +08:00
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));
}
[PatternMatch] Add matchers for vector operations Summary: There aren't any matchers for the three vector operations: insertelement, extractelement, and shufflevector. This patch adds them as well as corresponding unit tests. llvm-svn: 328709
2018-03-28 23:39:00 +08:00
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 = VectorType::get(IRB.getInt8Ty(), 2);
Type *i32 = IRB.getInt32Ty();
Type *i32VecTy = VectorType::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_InsertElement(m_Value(), m_Value(), m_Value())));
EXPECT_TRUE(
match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt())));
EXPECT_TRUE(
match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero())));
EXPECT_TRUE(
match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero())));
EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value())));
EXPECT_FALSE(
match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt())));
EXPECT_FALSE(
match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value())));
EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value())));
EXPECT_TRUE(match(VI3, m_InsertElement(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_ExtractElement(m_Value(A), m_Value(B))));
EXPECT_TRUE(A == VI4);
EXPECT_TRUE(B == Val);
A = B = C = nullptr; // reset
EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt())));
EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt())));
EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt())));
// Test matching shufflevector
EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero())));
EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C))));
EXPECT_TRUE(A == VI3);
EXPECT_TRUE(B == VI4);
EXPECT_TRUE(C == IdxVec);
A = B = C = nullptr; // reset
// Test matching the vector splat pattern
EXPECT_TRUE(match(
SI1,
m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()),
m_Undef(), m_Zero())));
EXPECT_FALSE(match(
SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
m_Undef(), m_Zero())));
EXPECT_FALSE(match(
SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
m_Undef(), m_Zero())));
EXPECT_TRUE(match(
SP1,
m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()),
m_Undef(), m_Zero())));
EXPECT_TRUE(match(
SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()),
m_Undef(), m_Zero())));
EXPECT_TRUE(A == Val);
}
[PatternMatch] Handle undef vectors consistently This patch fixes the issue noticed in D54532. The problem is that cst_pred_ty-based matchers like m_Zero() currently do not match scalar undefs (as expected), but *do* match vector undefs. This may lead to optimization inconsistencies in rare cases. There is only one existing test for which output changes, reverting the change from D53205. The reason here is that vector fsub undef, %x is no longer matched as an m_FNeg(). While I think that the new output is technically worse than the previous one, it is consistent with scalar, and I don't think it's really important either way (generally that undef should have been folded away prior to reassociation.) I've also added another test case for this issue based on InstructionSimplify. It took some effort to find that one, as in most cases undef folds are either checked first -- and in the cases where they aren't it usually happens to not make a difference in the end. This is the only case I was able to come up with. Prior to this patch the test case simplified to undef in the scalar case, but zeroinitializer in the vector case. Patch by: @nikic (Nikita Popov) Differential Revision: https://reviews.llvm.org/D54631 llvm-svn: 347318
2018-11-21 00:08:19 +08:00
TEST_F(PatternMatchTest, VectorUndefInt) {
Type *ScalarTy = IRB.getInt8Ty();
Type *VectorTy = VectorType::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()));
}
TEST_F(PatternMatchTest, VectorUndefFloat) {
Type *ScalarTy = IRB.getFloatTy();
Type *VectorTy = VectorType::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_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()));
}
Update PatternMatcher for FNeg Match both FNeg(X) and FSub(+-0.0, X) in FNeg_match Differential Revision: https://reviews.llvm.org/D61520 llvm-svn: 359936
2019-05-04 05:19:12 +08:00
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))));
}
[PatternMatch] Make m_Br more flexible, add matchers for BB values. Currently m_Br only takes references to BasicBlock*, which limits its flexibility. For example, you have to declare a variable, even if you ignore the result or you have to have additional checks to make sure the matched BB matches an expected one. This patch adds m_BasicBlock and m_SpecificBB matchers, which can be used like the existing matchers for constants or values. I also had a look at the existing uses and updated a few. IMO it makes the code a bit more explicit. Reviewers: spatel, craig.topper, RKSimon, majnemer, lebedev.ri Reviewed By: lebedev.ri Differential Revision: https://reviews.llvm.org/D68013 llvm-svn: 372885
2019-09-25 23:05:08 +08:00
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))));
}
[PatternMatch] Add m_WithOverflowInst and m_ExtractValue matchers Used in D69245, these add pattern matchers for the WithOverflowInst (capturing the result) and the ExtractValue instructions taking a template parameter specifying the element being extracted.
2019-10-31 19:47:47 +08:00
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);
}
[PatternMatch] Add support for matching intrinsics with 5 operands. Summary: Also adds a test to the pattern matching unit tests. Reviewers: spatel, craig.topper, RKSimon, majnemer, lebedev.ri Reviewed By: spatel Subscribers: merge_guards_bot, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D70892
2019-12-02 23:29:53 +08:00
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))));
}
Add support to paternmatch for simple const Value cases. Pattern match has some paths which can operate on constant instructions, but not all. This adds a version of m_value() to return const Value* and changes ICmp matching to use auto so that it can match both constant and mutable instructions. Tests also included for both mutable and constant ICmpInst matching. This will be used in a future commit to constify ValueTracking.cpp. llvm-svn: 278570
2016-08-13 06:16:05 +08:00
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);
}
PatternMatch: Matcher for (un)ordered floating point min/max Add support for matching 'ordered' and 'unordered' floating point min/max constructs. In LLVM we can express min/max functions as a combination of compare and select. We have support for matching such constructs for integers but not for floating point. In floating point math there is no total order because of the presence of 'NaN'. Therefore, we have to be careful to preserve the original fcmp semantics when interpreting floating point compare select combinations as a minimum or maximum function. The resulting 'ordered/unordered' floating point maximum function has to select the same value as the select/fcmp combination it is based on. ordered_max(x,y) = max(x,y) iff x and y are not NaN, y otherwise unordered_max(x,y) = max(x,y) iff x and y are not NaN, x otherwise ordered_min(x,y) = min(x,y) iff x and y are not NaN, y otherwise unordered_min(x,y) = min(x,y) iff x and y are not NaN, x otherwise This matches the behavior of the underlying select(fcmp(olt/ult/.., L, R), L, R) construct. Any code using this predicate has to preserve this semantics. A follow-up patch will use this to implement floating point min/max reductions in the vectorizer. radar://13723044 llvm-svn: 181143
2013-05-05 09:54:46 +08:00
} // anonymous namespace.