LLVM 19.0.0git
CmpInstAnalysis.cpp
Go to the documentation of this file.
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
15#include "llvm/IR/Constants.h"
18
19using namespace llvm;
20
22 switch (Pred) {
23 // False -> 0
24 case ICmpInst::ICMP_UGT: return 1; // 001
25 case ICmpInst::ICMP_SGT: return 1; // 001
26 case ICmpInst::ICMP_EQ: return 2; // 010
27 case ICmpInst::ICMP_UGE: return 3; // 011
28 case ICmpInst::ICMP_SGE: return 3; // 011
29 case ICmpInst::ICMP_ULT: return 4; // 100
30 case ICmpInst::ICMP_SLT: return 4; // 100
31 case ICmpInst::ICMP_NE: return 5; // 101
32 case ICmpInst::ICMP_ULE: return 6; // 110
33 case ICmpInst::ICMP_SLE: return 6; // 110
34 // True -> 7
35 default:
36 llvm_unreachable("Invalid ICmp predicate!");
37 }
38}
39
40Constant *llvm::getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,
41 CmpInst::Predicate &Pred) {
42 switch (Code) {
43 default: llvm_unreachable("Illegal ICmp code!");
44 case 0: // False.
45 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 0);
46 case 1: Pred = Sign ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; break;
47 case 2: Pred = ICmpInst::ICMP_EQ; break;
48 case 3: Pred = Sign ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE; break;
49 case 4: Pred = Sign ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; break;
50 case 5: Pred = ICmpInst::ICMP_NE; break;
51 case 6: Pred = Sign ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE; break;
52 case 7: // True.
53 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 1);
54 }
55 return nullptr;
56}
57
59 return (CmpInst::isSigned(P1) == CmpInst::isSigned(P2)) ||
62}
63
65 CmpInst::Predicate &Pred) {
66 Pred = static_cast<FCmpInst::Predicate>(Code);
67 assert(FCmpInst::FCMP_FALSE <= Pred && Pred <= FCmpInst::FCMP_TRUE &&
68 "Unexpected FCmp predicate!");
69 if (Pred == FCmpInst::FCMP_FALSE)
70 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 0);
71 if (Pred == FCmpInst::FCMP_TRUE)
72 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 1);
73 return nullptr;
74}
75
78 Value *&X, APInt &Mask, bool LookThruTrunc) {
79 using namespace PatternMatch;
80
81 const APInt *C;
83 return false;
84
85 switch (Pred) {
86 default:
87 return false;
88 case ICmpInst::ICMP_SLT:
89 // X < 0 is equivalent to (X & SignMask) != 0.
90 if (!C->isZero())
91 return false;
92 Mask = APInt::getSignMask(C->getBitWidth());
93 Pred = ICmpInst::ICMP_NE;
94 break;
95 case ICmpInst::ICMP_SLE:
96 // X <= -1 is equivalent to (X & SignMask) != 0.
97 if (!C->isAllOnes())
98 return false;
99 Mask = APInt::getSignMask(C->getBitWidth());
100 Pred = ICmpInst::ICMP_NE;
101 break;
102 case ICmpInst::ICMP_SGT:
103 // X > -1 is equivalent to (X & SignMask) == 0.
104 if (!C->isAllOnes())
105 return false;
106 Mask = APInt::getSignMask(C->getBitWidth());
107 Pred = ICmpInst::ICMP_EQ;
108 break;
109 case ICmpInst::ICMP_SGE:
110 // X >= 0 is equivalent to (X & SignMask) == 0.
111 if (!C->isZero())
112 return false;
113 Mask = APInt::getSignMask(C->getBitWidth());
114 Pred = ICmpInst::ICMP_EQ;
115 break;
116 case ICmpInst::ICMP_ULT:
117 // X <u 2^n is equivalent to (X & ~(2^n-1)) == 0.
118 if (!C->isPowerOf2())
119 return false;
120 Mask = -*C;
121 Pred = ICmpInst::ICMP_EQ;
122 break;
123 case ICmpInst::ICMP_ULE:
124 // X <=u 2^n-1 is equivalent to (X & ~(2^n-1)) == 0.
125 if (!(*C + 1).isPowerOf2())
126 return false;
127 Mask = ~*C;
128 Pred = ICmpInst::ICMP_EQ;
129 break;
130 case ICmpInst::ICMP_UGT:
131 // X >u 2^n-1 is equivalent to (X & ~(2^n-1)) != 0.
132 if (!(*C + 1).isPowerOf2())
133 return false;
134 Mask = ~*C;
135 Pred = ICmpInst::ICMP_NE;
136 break;
137 case ICmpInst::ICMP_UGE:
138 // X >=u 2^n is equivalent to (X & ~(2^n-1)) != 0.
139 if (!C->isPowerOf2())
140 return false;
141 Mask = -*C;
142 Pred = ICmpInst::ICMP_NE;
143 break;
144 }
145
146 if (LookThruTrunc && match(LHS, m_Trunc(m_Value(X)))) {
147 Mask = Mask.zext(X->getType()->getScalarSizeInBits());
148 } else {
149 X = LHS;
150 }
151
152 return true;
153}
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:76
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
Definition: APInt.h:207
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:1362
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:993
bool isSigned() const
Definition: InstrTypes.h:1265
This is an important base class in LLVM.
Definition: Constant.h:41
bool isEquality() const
Return true if this predicate is either EQ or NE.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
Definition: PatternMatch.h:300
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:92
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Constant * getPredForFCmpCode(unsigned Code, Type *OpTy, CmpInst::Predicate &Pred)
This is the complement of getFCmpCode.
bool predicatesFoldable(CmpInst::Predicate P1, CmpInst::Predicate P2)
Return true if both predicates match sign or if at least one of them is an equality comparison (which...
bool decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate &Pred, Value *&X, APInt &Mask, bool LookThroughTrunc=true)
Decompose an icmp into the form ((X & Mask) pred 0) if possible.
unsigned getICmpCode(CmpInst::Predicate Pred)
Encode a icmp predicate into a three bit mask.
Constant * getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy, CmpInst::Predicate &Pred)
This is the complement of getICmpCode.