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
19namespace llvm {
20 class Type;
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(CmpInst::Predicate Pred);
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).
59 bool predicatesFoldable(CmpInst::Predicate P1, CmpInst::Predicate P2);
60
61 /// Similar to getICmpCode but for FCmpInst. This encodes a fcmp predicate
62 /// into a four bit mask.
63 inline unsigned getFCmpCode(CmpInst::Predicate CC) {
64 assert(CmpInst::FCMP_FALSE <= CC && CC <= CmpInst::FCMP_TRUE &&
65 "Unexpected FCmp predicate!");
66 // Take advantage of the bit pattern of CmpInst::Predicate here.
67 // U L G E
68 static_assert(CmpInst::FCMP_FALSE == 0); // 0 0 0 0
69 static_assert(CmpInst::FCMP_OEQ == 1); // 0 0 0 1
70 static_assert(CmpInst::FCMP_OGT == 2); // 0 0 1 0
71 static_assert(CmpInst::FCMP_OGE == 3); // 0 0 1 1
72 static_assert(CmpInst::FCMP_OLT == 4); // 0 1 0 0
73 static_assert(CmpInst::FCMP_OLE == 5); // 0 1 0 1
74 static_assert(CmpInst::FCMP_ONE == 6); // 0 1 1 0
75 static_assert(CmpInst::FCMP_ORD == 7); // 0 1 1 1
76 static_assert(CmpInst::FCMP_UNO == 8); // 1 0 0 0
77 static_assert(CmpInst::FCMP_UEQ == 9); // 1 0 0 1
78 static_assert(CmpInst::FCMP_UGT == 10); // 1 0 1 0
79 static_assert(CmpInst::FCMP_UGE == 11); // 1 0 1 1
80 static_assert(CmpInst::FCMP_ULT == 12); // 1 1 0 0
81 static_assert(CmpInst::FCMP_ULE == 13); // 1 1 0 1
82 static_assert(CmpInst::FCMP_UNE == 14); // 1 1 1 0
83 static_assert(CmpInst::FCMP_TRUE == 15); // 1 1 1 1
84 return CC;
85 }
86
87 /// This is the complement of getFCmpCode. It turns a predicate code into
88 /// either a constant true or false or the predicate for a new FCmp.
89 /// Non-NULL return value will be a true or false constant.
90 /// NULL return means a new ICmp is needed. The predicate is output in Pred.
91 Constant *getPredForFCmpCode(unsigned Code, Type *OpTy,
92 CmpInst::Predicate &Pred);
93
94 /// Decompose an icmp into the form ((X & Mask) pred 0) if possible. The
95 /// returned predicate is either == or !=. Returns false if decomposition
96 /// fails.
97 bool decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate &Pred,
98 Value *&X, APInt &Mask,
99 bool LookThroughTrunc = true);
100
101} // end namespace llvm
102
103#endif
104

source code of llvm/include/llvm/Analysis/CmpInstAnalysis.h