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 final {
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 int8_t() const { return V; }
50   explicit operator uint8_t() const { return V; }
51   explicit operator int16_t() const { return V; }
52   explicit operator uint16_t() const { return V; }
53   explicit operator int32_t() const { return V; }
54   explicit operator uint32_t() const { return V; }
55   explicit operator int64_t() const { return V; }
56   explicit operator uint64_t() const { return V; }
57   explicit operator bool() const { return V; }
58 
59   APSInt toAPSInt() const {
60     return APSInt(APInt(1, static_cast<uint64_t>(V), false), true);
61   }
62   APSInt toAPSInt(unsigned NumBits) const {
63     return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
64   }
65   APValue toAPValue() const { return APValue(toAPSInt()); }
66 
67   Boolean toUnsigned() const { return *this; }
68 
69   constexpr static unsigned bitWidth() { return true; }
70   bool isZero() const { return !V; }
71   bool isMin() const { return isZero(); }
72 
73   constexpr static bool isMinusOne() { return false; }
74 
75   constexpr static bool isSigned() { return false; }
76 
77   constexpr static bool isNegative() { return false; }
78   constexpr static bool isPositive() { return !isNegative(); }
79 
80   ComparisonCategoryResult compare(const Boolean &RHS) const {
81     return Compare(V, RHS.V);
82   }
83 
84   unsigned countLeadingZeros() const { return V ? 0 : 1; }
85 
86   Boolean truncate(unsigned TruncBits) const { return *this; }
87 
88   void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
89 
90   static Boolean min(unsigned NumBits) { return Boolean(false); }
91   static Boolean max(unsigned NumBits) { return Boolean(true); }
92 
93   template <typename T> static Boolean from(T Value) {
94     if constexpr (std::is_integral<T>::value)
95       return Boolean(Value != 0);
96     return Boolean(static_cast<decltype(Boolean::V)>(Value) != 0);
97   }
98 
99   template <unsigned SrcBits, bool SrcSign>
100   static std::enable_if_t<SrcBits != 0, Boolean>
101   from(Integral<SrcBits, SrcSign> Value) {
102     return Boolean(!Value.isZero());
103   }
104 
105   template <bool SrcSign>
106   static Boolean from(Integral<0, SrcSign> Value) {
107     return Boolean(!Value.isZero());
108   }
109 
110   static Boolean zero() { return from(false); }
111 
112   template <typename T>
113   static Boolean from(T Value, unsigned NumBits) {
114     return Boolean(Value);
115   }
116 
117   static bool inRange(int64_t Value, unsigned NumBits) {
118     return Value == 0 || Value == 1;
119   }
120 
121   static bool increment(Boolean A, Boolean *R) {
122     *R = Boolean(true);
123     return false;
124   }
125 
126   static bool decrement(Boolean A, Boolean *R) {
127     llvm_unreachable("Cannot decrement booleans");
128   }
129 
130   static bool add(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
131     *R = Boolean(A.V || B.V);
132     return false;
133   }
134 
135   static bool sub(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
136     *R = Boolean(A.V ^ B.V);
137     return false;
138   }
139 
140   static bool mul(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
141     *R = Boolean(A.V && B.V);
142     return false;
143   }
144 
145   static bool inv(Boolean A, Boolean *R) {
146     *R = Boolean(!A.V);
147     return false;
148   }
149 
150   static bool neg(Boolean A, Boolean *R) {
151     *R = Boolean(A.V);
152     return false;
153   }
154 };
155 
156 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Boolean &B) {
157   B.print(OS);
158   return OS;
159 }
160 
161 }  // namespace interp
162 }  // namespace clang
163 
164 #endif
165