LLVM  15.0.0git
OverflowInstAnalysis.cpp
Go to the documentation of this file.
1 //==-- OverflowInstAnalysis.cpp - Utils to fold overflow insts ----*- C++ -*-=//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file holds routines to help analyse overflow instructions
10 // and fold them into constants or other overflow instructions
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/IR/Instructions.h"
16 #include "llvm/IR/PatternMatch.h"
17 
18 using namespace llvm;
19 using namespace llvm::PatternMatch;
20 
22  Use *&Y) {
24  Value *X, *NotOp1;
25  int XIdx;
26  IntrinsicInst *II;
27 
28  if (!match(Op0, m_ICmp(Pred, m_Value(X), m_Zero())))
29  return false;
30 
31  /// %Agg = call { i4, i1 } @llvm.[us]mul.with.overflow.i4(i4 %X, i4 %???)
32  /// %V = extractvalue { i4, i1 } %Agg, 1
33  auto matchMulOverflowCheck = [X, &II, &XIdx](Value *V) {
34  auto *Extract = dyn_cast<ExtractValueInst>(V);
35  // We should only be extracting the overflow bit.
36  if (!Extract || !Extract->getIndices().equals(1))
37  return false;
38 
39  II = dyn_cast<IntrinsicInst>(Extract->getAggregateOperand());
40  if (!II ||
41  !match(II, m_CombineOr(m_Intrinsic<Intrinsic::umul_with_overflow>(),
42  m_Intrinsic<Intrinsic::smul_with_overflow>())))
43  return false;
44 
45  if (II->getArgOperand(0) == X)
46  XIdx = 0;
47  else if (II->getArgOperand(1) == X)
48  XIdx = 1;
49  else
50  return false;
51  return true;
52  };
53 
54  bool Matched =
55  (IsAnd && Pred == ICmpInst::Predicate::ICMP_NE &&
56  matchMulOverflowCheck(Op1)) ||
57  (!IsAnd && Pred == ICmpInst::Predicate::ICMP_EQ &&
58  match(Op1, m_Not(m_Value(NotOp1))) && matchMulOverflowCheck(NotOp1));
59 
60  if (!Matched)
61  return false;
62 
63  Y = &II->getArgOperandUse(!XIdx);
64  return true;
65 }
66 
68  bool IsAnd) {
69  Use *Y;
70  return isCheckForZeroAndMulWithOverflow(Op0, Op1, IsAnd, Y);
71 }
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::isCheckForZeroAndMulWithOverflow
bool isCheckForZeroAndMulWithOverflow(Value *Op0, Value *Op1, bool IsAnd, Use *&Y)
Match one of the patterns up to the select/logic op: Op0 = icmp ne i4 X, 0 Agg = call { i4,...
Definition: OverflowInstAnalysis.cpp:21
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:719
llvm::PatternMatch::m_CombineOr
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:212
llvm::PatternMatch::m_Not
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
Definition: PatternMatch.h:2283
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
PatternMatch.h
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::PatternMatch::m_Zero
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:531
llvm::PatternMatch::m_Value
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:76
OverflowInstAnalysis.h
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:46
Instructions.h
llvm::PatternMatch::m_ICmp
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:1388
llvm::PatternMatch
Definition: PatternMatch.h:47
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43