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