4a0d53a0b0
With the introduction of CmpPredicate in 51a895a (IR: introduce struct with CmpInst::Predicate and samesign), PatternMatch is one of the first key pieces of infrastructure that must be updated to match a CmpInst respecting samesign information. Implement this change to Cmp-matchers. This is a preparatory step in migrating the codebase over to CmpPredicate. Since we no functional changes are desired at this stage, we have chosen not to migrate CmpPredicate::operator==(CmpPredicate) calls to use CmpPredicate::getMatching(), as that would have visible impact on tests that are not yet written: instead, we call CmpPredicate::operator==(Predicate), preserving the old behavior, while also inserting a few FIXME comments for follow-ups.
72 lines
2.3 KiB
C++
72 lines
2.3 KiB
C++
//==-- OverflowInstAnalysis.cpp - Utils to fold overflow insts ----*- C++ -*-=//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file holds routines to help analyse overflow instructions
|
|
// and fold them into constants or other overflow instructions
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/OverflowInstAnalysis.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/PatternMatch.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::PatternMatch;
|
|
|
|
bool llvm::isCheckForZeroAndMulWithOverflow(Value *Op0, Value *Op1, bool IsAnd,
|
|
Use *&Y) {
|
|
CmpPredicate Pred;
|
|
Value *X, *NotOp1;
|
|
int XIdx;
|
|
IntrinsicInst *II;
|
|
|
|
if (!match(Op0, m_ICmp(Pred, m_Value(X), m_Zero())))
|
|
return false;
|
|
|
|
/// %Agg = call { i4, i1 } @llvm.[us]mul.with.overflow.i4(i4 %X, i4 %???)
|
|
/// %V = extractvalue { i4, i1 } %Agg, 1
|
|
auto matchMulOverflowCheck = [X, &II, &XIdx](Value *V) {
|
|
auto *Extract = dyn_cast<ExtractValueInst>(V);
|
|
// We should only be extracting the overflow bit.
|
|
if (!Extract || !Extract->getIndices().equals(1))
|
|
return false;
|
|
|
|
II = dyn_cast<IntrinsicInst>(Extract->getAggregateOperand());
|
|
if (!II ||
|
|
!match(II, m_CombineOr(m_Intrinsic<Intrinsic::umul_with_overflow>(),
|
|
m_Intrinsic<Intrinsic::smul_with_overflow>())))
|
|
return false;
|
|
|
|
if (II->getArgOperand(0) == X)
|
|
XIdx = 0;
|
|
else if (II->getArgOperand(1) == X)
|
|
XIdx = 1;
|
|
else
|
|
return false;
|
|
return true;
|
|
};
|
|
|
|
bool Matched =
|
|
(IsAnd && Pred == ICmpInst::Predicate::ICMP_NE &&
|
|
matchMulOverflowCheck(Op1)) ||
|
|
(!IsAnd && Pred == ICmpInst::Predicate::ICMP_EQ &&
|
|
match(Op1, m_Not(m_Value(NotOp1))) && matchMulOverflowCheck(NotOp1));
|
|
|
|
if (!Matched)
|
|
return false;
|
|
|
|
Y = &II->getArgOperandUse(!XIdx);
|
|
return true;
|
|
}
|
|
|
|
bool llvm::isCheckForZeroAndMulWithOverflow(Value *Op0, Value *Op1,
|
|
bool IsAnd) {
|
|
Use *Y;
|
|
return isCheckForZeroAndMulWithOverflow(Op0, Op1, IsAnd, Y);
|
|
}
|