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 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 | |