LLVM  14.0.0git
CmpInstAnalysis.h
Go to the documentation of this file.
1 //===-- CmpInstAnalysis.h - Utils to help fold compare 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 compare instructions
10 // and fold them into constants or other compare instructions
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_ANALYSIS_CMPINSTANALYSIS_H
15 #define LLVM_ANALYSIS_CMPINSTANALYSIS_H
16 
17 #include "llvm/IR/InstrTypes.h"
18 
19 namespace llvm {
20  class ICmpInst;
21  class Value;
22 
23  /// Encode a icmp predicate into a three bit mask. These bits are carefully
24  /// arranged to allow folding of expressions such as:
25  ///
26  /// (A < B) | (A > B) --> (A != B)
27  ///
28  /// Note that this is only valid if the first and second predicates have the
29  /// same sign. It is illegal to do: (A u< B) | (A s> B)
30  ///
31  /// Three bits are used to represent the condition, as follows:
32  /// 0 A > B
33  /// 1 A == B
34  /// 2 A < B
35  ///
36  /// <=> Value Definition
37  /// 000 0 Always false
38  /// 001 1 A > B
39  /// 010 2 A == B
40  /// 011 3 A >= B
41  /// 100 4 A < B
42  /// 101 5 A != B
43  /// 110 6 A <= B
44  /// 111 7 Always true
45  ///
46  unsigned getICmpCode(const ICmpInst *ICI, bool InvertPred = false);
47 
48  /// This is the complement of getICmpCode. It turns a predicate code into
49  /// either a constant true or false or the predicate for a new ICmp.
50  /// The sign is passed in to determine which kind of predicate to use in the
51  /// new ICmp instruction.
52  /// Non-NULL return value will be a true or false constant.
53  /// NULL return means a new ICmp is needed. The predicate is output in Pred.
54  Constant *getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,
55  CmpInst::Predicate &Pred);
56 
57  /// Return true if both predicates match sign or if at least one of them is an
58  /// equality comparison (which is signless).
60 
61  /// Decompose an icmp into the form ((X & Mask) pred 0) if possible. The
62  /// returned predicate is either == or !=. Returns false if decomposition
63  /// fails.
64  bool decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate &Pred,
65  Value *&X, APInt &Mask,
66  bool LookThroughTrunc = true);
67 
68 } // end namespace llvm
69 
70 #endif
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
llvm::tgtok::Code
@ Code
Definition: TGLexer.h:50
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::predicatesFoldable
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...
Definition: CmpInstAnalysis.cpp:60
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
P2
This might compile to this xmm1 xorps xmm0 movss xmm0 ret Now consider if the code caused xmm1 to get spilled This might produce this xmm1 movaps xmm0 movaps xmm1 movss xmm0 ret since the reload is only used by these we could fold it into the producing something like xmm1 movaps xmm0 ret saving two instructions The basic idea is that a reload from a spill if only one byte chunk is bring in zeros the one element instead of elements This can be used to simplify a variety of shuffle where the elements are fixed zeros This code generates ugly probably due to costs being off or< 4 x float > * P2
Definition: README-SSE.txt:278
InstrTypes.h
llvm::getICmpCode
unsigned getICmpCode(const ICmpInst *ICI, bool InvertPred=false)
Encode a icmp predicate into a three bit mask.
Definition: CmpInstAnalysis.cpp:21
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
TemplateParamKind::Type
@ Type
llvm::decomposeBitTestICmp
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.
Definition: CmpInstAnalysis.cpp:66
llvm::getPredForICmpCode
Constant * getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy, CmpInst::Predicate &Pred)
This is the complement of getICmpCode.
Definition: CmpInstAnalysis.cpp:42
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27