clang/lib/AST/Interp/Boolean.h

   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  public:
  31   /// Zero-initializes a boolean.
  32   Boolean() : V(false) {}
  33   explicit Boolean(bool V) : V(V) {}
  34
  35   bool operator<(Boolean RHS) const { return V < RHS.V; }
  36   bool operator>(Boolean RHS) const { return V > RHS.V; }
  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
  42   bool operator>(unsigned RHS) const { return static_cast<unsigned>(V) > RHS; }
  43
  44   Boolean operator-() const { return Boolean(V); }
  45   Boolean operator-(const Boolean &Other) const { return Boolean(V - Other.V); }
  46   Boolean operator~() const { return Boolean(true); }
  47
  48   explicit operator int8_t() const { return V; }
  49   explicit operator uint8_t() const { return V; }
  50   explicit operator int16_t() const { return V; }
  51   explicit operator uint16_t() const { return V; }
  52   explicit operator int32_t() const { return V; }
  53   explicit operator uint32_t() const { return V; }
  54   explicit operator int64_t() const { return V; }
  55   explicit operator uint64_t() const { return V; }
  56   explicit operator bool() const { return V; }
  57
  58   APSInt toAPSInt() const {
  59     return APSInt(APInt(1, static_cast<uint64_t>(V), false), true);
  60   }
  61   APSInt toAPSInt(unsigned NumBits) const {
  62     return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
  63   }
  64   APValue toAPValue() const { return APValue(toAPSInt()); }
  65
  66   Boolean toUnsigned() const { return *this; }
  67
  68   constexpr static unsigned bitWidth() { return 1; }
  69   bool isZero() const { return !V; }
  70   bool isMin() const { return isZero(); }
  71
  72   constexpr static bool isMinusOne() { return false; }
  73
  74   constexpr static bool isSigned() { return false; }
  75
  76   constexpr static bool isNegative() { return false; }
  77   constexpr static bool isPositive() { return !isNegative(); }
  78
  79   ComparisonCategoryResult compare(const Boolean &RHS) const {
  80     return Compare(V, RHS.V);
  81   }
  82
  83   unsigned countLeadingZeros() const { return V ? 0 : 1; }
  84
  85   Boolean truncate(unsigned TruncBits) const { return *this; }
  86
  87   void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
  88   std::string toDiagnosticString(const ASTContext &Ctx) const {
  89     std::string NameStr;
  90     llvm::raw_string_ostream OS(NameStr);
  91     print(OS);
  92     return NameStr;
  93   }
  94
  95   static Boolean min(unsigned NumBits) { return Boolean(false); }
  96   static Boolean max(unsigned NumBits) { return Boolean(true); }
  97
  98   template <typename T> static Boolean from(T Value) {
  99     if constexpr (std::is_integral<T>::value)
 100       return Boolean(Value != 0);
 101     return Boolean(static_cast<decltype(Boolean::V)>(Value) != 0);
 102   }
 103
 104   template <unsigned SrcBits, bool SrcSign>
 105   static std::enable_if_t<SrcBits != 0, Boolean>
 106   from(Integral<SrcBits, 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