|
150
|
1 //===--- Boolean.h - Wrapper for boolean types for the VM -------*- 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 #ifndef LLVM_CLANG_AST_INTERP_BOOLEAN_H
|
|
|
10 #define LLVM_CLANG_AST_INTERP_BOOLEAN_H
|
|
|
11
|
|
|
12 #include <cstddef>
|
|
|
13 #include <cstdint>
|
|
|
14 #include "Integral.h"
|
|
|
15 #include "clang/AST/APValue.h"
|
|
|
16 #include "clang/AST/ComparisonCategories.h"
|
|
|
17 #include "llvm/ADT/APSInt.h"
|
|
|
18 #include "llvm/Support/MathExtras.h"
|
|
|
19 #include "llvm/Support/raw_ostream.h"
|
|
|
20
|
|
|
21 namespace clang {
|
|
|
22 namespace interp {
|
|
|
23
|
|
|
24 /// Wrapper around boolean types.
|
|
|
25 class Boolean {
|
|
|
26 private:
|
|
|
27 /// Underlying boolean.
|
|
|
28 bool V;
|
|
|
29
|
|
|
30 /// Construct a wrapper from a boolean.
|
|
|
31 explicit Boolean(bool V) : V(V) {}
|
|
|
32
|
|
|
33 public:
|
|
|
34 /// Zero-initializes a boolean.
|
|
|
35 Boolean() : V(false) {}
|
|
|
36
|
|
|
37 bool operator<(Boolean RHS) const { return V < RHS.V; }
|
|
|
38 bool operator>(Boolean RHS) const { return V > RHS.V; }
|
|
|
39 bool operator<=(Boolean RHS) const { return V <= RHS.V; }
|
|
|
40 bool operator>=(Boolean RHS) const { return V >= RHS.V; }
|
|
|
41 bool operator==(Boolean RHS) const { return V == RHS.V; }
|
|
|
42 bool operator!=(Boolean RHS) const { return V != RHS.V; }
|
|
|
43
|
|
|
44 bool operator>(unsigned RHS) const { return static_cast<unsigned>(V) > RHS; }
|
|
|
45
|
|
|
46 Boolean operator-() const { return Boolean(V); }
|
|
|
47 Boolean operator~() const { return Boolean(true); }
|
|
|
48
|
|
|
49 explicit operator unsigned() const { return V; }
|
|
|
50 explicit operator int64_t() const { return V; }
|
|
|
51 explicit operator uint64_t() const { return V; }
|
|
|
52
|
|
|
53 APSInt toAPSInt() const {
|
|
|
54 return APSInt(APInt(1, static_cast<uint64_t>(V), false), true);
|
|
|
55 }
|
|
|
56 APSInt toAPSInt(unsigned NumBits) const {
|
|
|
57 return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
|
|
|
58 }
|
|
|
59 APValue toAPValue() const { return APValue(toAPSInt()); }
|
|
|
60
|
|
|
61 Boolean toUnsigned() const { return *this; }
|
|
|
62
|
|
|
63 constexpr static unsigned bitWidth() { return true; }
|
|
|
64 bool isZero() const { return !V; }
|
|
|
65 bool isMin() const { return isZero(); }
|
|
|
66
|
|
|
67 constexpr static bool isMinusOne() { return false; }
|
|
|
68
|
|
|
69 constexpr static bool isSigned() { return false; }
|
|
|
70
|
|
|
71 constexpr static bool isNegative() { return false; }
|
|
|
72 constexpr static bool isPositive() { return !isNegative(); }
|
|
|
73
|
|
|
74 ComparisonCategoryResult compare(const Boolean &RHS) const {
|
|
|
75 return Compare(V, RHS.V);
|
|
|
76 }
|
|
|
77
|
|
|
78 unsigned countLeadingZeros() const { return V ? 0 : 1; }
|
|
|
79
|
|
|
80 Boolean truncate(unsigned TruncBits) const { return *this; }
|
|
|
81
|
|
|
82 void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
|
|
|
83
|
|
|
84 static Boolean min(unsigned NumBits) { return Boolean(false); }
|
|
|
85 static Boolean max(unsigned NumBits) { return Boolean(true); }
|
|
|
86
|
|
|
87 template <typename T>
|
|
|
88 static std::enable_if_t<std::is_integral<T>::value, Boolean> from(T Value) {
|
|
|
89 return Boolean(Value != 0);
|
|
|
90 }
|
|
|
91
|
|
|
92 template <unsigned SrcBits, bool SrcSign>
|
|
|
93 static std::enable_if_t<SrcBits != 0, Boolean>
|
|
|
94 from(Integral<SrcBits, SrcSign> Value) {
|
|
|
95 return Boolean(!Value.isZero());
|
|
|
96 }
|
|
|
97
|
|
|
98 template <bool SrcSign>
|
|
|
99 static Boolean from(Integral<0, SrcSign> Value) {
|
|
|
100 return Boolean(!Value.isZero());
|
|
|
101 }
|
|
|
102
|
|
|
103 static Boolean zero() { return from(false); }
|
|
|
104
|
|
|
105 template <typename T>
|
|
|
106 static Boolean from(T Value, unsigned NumBits) {
|
|
|
107 return Boolean(Value);
|
|
|
108 }
|
|
|
109
|
|
|
110 static bool inRange(int64_t Value, unsigned NumBits) {
|
|
|
111 return Value == 0 || Value == 1;
|
|
|
112 }
|
|
|
113
|
|
|
114 static bool increment(Boolean A, Boolean *R) {
|
|
|
115 *R = Boolean(true);
|
|
|
116 return false;
|
|
|
117 }
|
|
|
118
|
|
|
119 static bool decrement(Boolean A, Boolean *R) {
|
|
|
120 llvm_unreachable("Cannot decrement booleans");
|
|
|
121 }
|
|
|
122
|
|
|
123 static bool add(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
|
|
|
124 *R = Boolean(A.V || B.V);
|
|
|
125 return false;
|
|
|
126 }
|
|
|
127
|
|
|
128 static bool sub(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
|
|
|
129 *R = Boolean(A.V ^ B.V);
|
|
|
130 return false;
|
|
|
131 }
|
|
|
132
|
|
|
133 static bool mul(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
|
|
|
134 *R = Boolean(A.V && B.V);
|
|
|
135 return false;
|
|
|
136 }
|
|
|
137 };
|
|
|
138
|
|
|
139 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Boolean &B) {
|
|
|
140 B.print(OS);
|
|
|
141 return OS;
|
|
|
142 }
|
|
|
143
|
|
|
144 } // namespace interp
|
|
|
145 } // namespace clang
|
|
|
146
|
|
|
147 #endif
|
