|
150
|
1 //===- CmpInstAnalysis.cpp - Utils to help fold compares ---------------===//
|
|
|
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 compare instructions
|
|
|
10 // and fold them into constants or other compare instructions
|
|
|
11 //
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13
|
|
|
14 #include "llvm/Analysis/CmpInstAnalysis.h"
|
|
|
15 #include "llvm/IR/Constants.h"
|
|
|
16 #include "llvm/IR/Instructions.h"
|
|
|
17 #include "llvm/IR/PatternMatch.h"
|
|
|
18
|
|
|
19 using namespace llvm;
|
|
|
20
|
|
|
21 unsigned llvm::getICmpCode(const ICmpInst *ICI, bool InvertPred) {
|
|
|
22 ICmpInst::Predicate Pred = InvertPred ? ICI->getInversePredicate()
|
|
|
23 : ICI->getPredicate();
|
|
|
24 switch (Pred) {
|
|
|
25 // False -> 0
|
|
|
26 case ICmpInst::ICMP_UGT: return 1; // 001
|
|
|
27 case ICmpInst::ICMP_SGT: return 1; // 001
|
|
|
28 case ICmpInst::ICMP_EQ: return 2; // 010
|
|
|
29 case ICmpInst::ICMP_UGE: return 3; // 011
|
|
|
30 case ICmpInst::ICMP_SGE: return 3; // 011
|
|
|
31 case ICmpInst::ICMP_ULT: return 4; // 100
|
|
|
32 case ICmpInst::ICMP_SLT: return 4; // 100
|
|
|
33 case ICmpInst::ICMP_NE: return 5; // 101
|
|
|
34 case ICmpInst::ICMP_ULE: return 6; // 110
|
|
|
35 case ICmpInst::ICMP_SLE: return 6; // 110
|
|
|
36 // True -> 7
|
|
|
37 default:
|
|
|
38 llvm_unreachable("Invalid ICmp predicate!");
|
|
|
39 }
|
|
|
40 }
|
|
|
41
|
|
|
42 Constant *llvm::getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,
|
|
|
43 CmpInst::Predicate &Pred) {
|
|
|
44 switch (Code) {
|
|
|
45 default: llvm_unreachable("Illegal ICmp code!");
|
|
|
46 case 0: // False.
|
|
|
47 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 0);
|
|
|
48 case 1: Pred = Sign ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; break;
|
|
|
49 case 2: Pred = ICmpInst::ICMP_EQ; break;
|
|
|
50 case 3: Pred = Sign ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE; break;
|
|
|
51 case 4: Pred = Sign ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; break;
|
|
|
52 case 5: Pred = ICmpInst::ICMP_NE; break;
|
|
|
53 case 6: Pred = Sign ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE; break;
|
|
|
54 case 7: // True.
|
|
|
55 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 1);
|
|
|
56 }
|
|
|
57 return nullptr;
|
|
|
58 }
|
|
|
59
|
|
|
60 bool llvm::predicatesFoldable(ICmpInst::Predicate P1, ICmpInst::Predicate P2) {
|
|
|
61 return (CmpInst::isSigned(P1) == CmpInst::isSigned(P2)) ||
|
|
|
62 (CmpInst::isSigned(P1) && ICmpInst::isEquality(P2)) ||
|
|
|
63 (CmpInst::isSigned(P2) && ICmpInst::isEquality(P1));
|
|
|
64 }
|
|
|
65
|
|
|
66 bool llvm::decomposeBitTestICmp(Value *LHS, Value *RHS,
|
|
|
67 CmpInst::Predicate &Pred,
|
|
|
68 Value *&X, APInt &Mask, bool LookThruTrunc) {
|
|
|
69 using namespace PatternMatch;
|
|
|
70
|
|
|
71 const APInt *C;
|
|
|
72 if (!match(RHS, m_APInt(C)))
|
|
|
73 return false;
|
|
|
74
|
|
|
75 switch (Pred) {
|
|
|
76 default:
|
|
|
77 return false;
|
|
|
78 case ICmpInst::ICMP_SLT:
|
|
|
79 // X < 0 is equivalent to (X & SignMask) != 0.
|
|
|
80 if (!C->isNullValue())
|
|
|
81 return false;
|
|
|
82 Mask = APInt::getSignMask(C->getBitWidth());
|
|
|
83 Pred = ICmpInst::ICMP_NE;
|
|
|
84 break;
|
|
|
85 case ICmpInst::ICMP_SLE:
|
|
|
86 // X <= -1 is equivalent to (X & SignMask) != 0.
|
|
|
87 if (!C->isAllOnesValue())
|
|
|
88 return false;
|
|
|
89 Mask = APInt::getSignMask(C->getBitWidth());
|
|
|
90 Pred = ICmpInst::ICMP_NE;
|
|
|
91 break;
|
|
|
92 case ICmpInst::ICMP_SGT:
|
|
|
93 // X > -1 is equivalent to (X & SignMask) == 0.
|
|
|
94 if (!C->isAllOnesValue())
|
|
|
95 return false;
|
|
|
96 Mask = APInt::getSignMask(C->getBitWidth());
|
|
|
97 Pred = ICmpInst::ICMP_EQ;
|
|
|
98 break;
|
|
|
99 case ICmpInst::ICMP_SGE:
|
|
|
100 // X >= 0 is equivalent to (X & SignMask) == 0.
|
|
|
101 if (!C->isNullValue())
|
|
|
102 return false;
|
|
|
103 Mask = APInt::getSignMask(C->getBitWidth());
|
|
|
104 Pred = ICmpInst::ICMP_EQ;
|
|
|
105 break;
|
|
|
106 case ICmpInst::ICMP_ULT:
|
|
|
107 // X <u 2^n is equivalent to (X & ~(2^n-1)) == 0.
|
|
|
108 if (!C->isPowerOf2())
|
|
|
109 return false;
|
|
|
110 Mask = -*C;
|
|
|
111 Pred = ICmpInst::ICMP_EQ;
|
|
|
112 break;
|
|
|
113 case ICmpInst::ICMP_ULE:
|
|
|
114 // X <=u 2^n-1 is equivalent to (X & ~(2^n-1)) == 0.
|
|
|
115 if (!(*C + 1).isPowerOf2())
|
|
|
116 return false;
|
|
|
117 Mask = ~*C;
|
|
|
118 Pred = ICmpInst::ICMP_EQ;
|
|
|
119 break;
|
|
|
120 case ICmpInst::ICMP_UGT:
|
|
|
121 // X >u 2^n-1 is equivalent to (X & ~(2^n-1)) != 0.
|
|
|
122 if (!(*C + 1).isPowerOf2())
|
|
|
123 return false;
|
|
|
124 Mask = ~*C;
|
|
|
125 Pred = ICmpInst::ICMP_NE;
|
|
|
126 break;
|
|
|
127 case ICmpInst::ICMP_UGE:
|
|
|
128 // X >=u 2^n is equivalent to (X & ~(2^n-1)) != 0.
|
|
|
129 if (!C->isPowerOf2())
|
|
|
130 return false;
|
|
|
131 Mask = -*C;
|
|
|
132 Pred = ICmpInst::ICMP_NE;
|
|
|
133 break;
|
|
|
134 }
|
|
|
135
|
|
|
136 if (LookThruTrunc && match(LHS, m_Trunc(m_Value(X)))) {
|
|
|
137 Mask = Mask.zext(X->getType()->getScalarSizeInBits());
|
|
|
138 } else {
|
|
|
139 X = LHS;
|
|
|
140 }
|
|
|
141
|
|
|
142 return true;
|
|
|
143 }
|
