[clang][Interp] Implement IntegralToBoolean casts

[tbaeder]

Summary

Redo how we do IntegralCasts and implement IntegralToBoolean casts using the already existing cast op.

[erichkeane]

clang/lib/AST/Interp/Opcodes.td

433

Not sure how this works... but is this ONLY int-32 to bool and vice versa? The implementation of any of the other integrals should be trivial.

[tbaeder]

clang/lib/AST/Interp/Opcodes.td

433

Yes exactly, the primitive types are:

def Bool : Type;
def Sint8 : Type;
def Uint8 : Type;
def Sint16 : Type;
def Uint16 : Type;
def Sint32 : Type;
def Uint32 : Type;
def Sint64 : Type;
def Uint64 : Type;
def Ptr : Type;

[erichkeane]

clang/lib/AST/Interp/Opcodes.td

433

So why not fill them in here as well?

[tbaeder]

clang/lib/AST/Interp/Opcodes.td

433

I think I can add Uint32 as well, but for the others I can't write tests yet since I don't have their literals implemented yet.

[erichkeane]

clang/lib/AST/Interp/Opcodes.td

433

Got it, thanks!

[aaron.ballman]

LGTM!

[shafik]

clang/lib/AST/Interp/Boolean.h

90

This should work for floating_point as well.

91

Why the != 0 shouldn't these all implicitly convert to bool with appropriate values?

[tbaeder]

clang/lib/AST/Interp/Boolean.h

90

We don't do floating point values yet.

91

Not 100% sure why this was used, it was there before so I left it in.

clang/lib/AST/Interp/Boolean.h

public:
 
   Boolean operator-() const { return Boolean(V); }
   Boolean operator~() const { return Boolean(true); }
 
   explicit operator unsigned() const { return V; }
   explicit operator int64_t() const { return V; }
   explicit operator uint64_t() const { return V; }
   explicit operator int() const { return V; }
+  explicit operator bool() const { return V; }
 
   APSInt toAPSInt() const {
     return APSInt(APInt(1, static_cast<uint64_t>(V), false), true);
   }
   APSInt toAPSInt(unsigned NumBits) const {
     return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
   }
   APValue toAPValue() const { return APValue(toAPSInt()); }
public:
 
   Boolean truncate(unsigned TruncBits) const { return *this; }
 
   void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
 
   static Boolean min(unsigned NumBits) { return Boolean(false); }
   static Boolean max(unsigned NumBits) { return Boolean(true); }
 
-  template <typename T>
-  static std::enable_if_t<std::is_integral<T>::value, Boolean> from(T Value) {
+  template <typename T> static Boolean from(T Value) {
+    if constexpr (std::is_integral<T>::value)
       return Boolean(Value != 0);
+    return Boolean(static_cast<decltype(Boolean::V)>(Value) != 0);
   }
 
   template <unsigned SrcBits, bool SrcSign>
   static std::enable_if_t<SrcBits != 0, Boolean>
   from(Integral<SrcBits, SrcSign> Value) {
     return Boolean(!Value.isZero());
   }
 

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_NullToPointer:
     return this->Visit(SubExpr);
 
+  case CK_IntegralToBoolean:
   case CK_IntegralCast: {
     Optional<PrimType> FromT = classify(SubExpr->getType());
     Optional<PrimType> ToT = classify(CE->getType());
     if (!FromT || !ToT)
       return false;
 
     if (!this->Visit(SubExpr))
       return false;
 
     return this->emitCast(*FromT, *ToT, CE);
   }
 
   case CK_ToVoid:
     return discard(SubExpr);
 
-  case CK_IntegralToBoolean:
-    // Compare integral from Subexpr with 0
-    if (Optional<PrimType> T = classify(SubExpr->getType())) {
-      if (!this->Visit(SubExpr))
-        return false;
-
-      if (!this->emitConst(SubExpr, 0))
-        return false;
-
-      return this->emitNE(*T, SubExpr);
-    }
-    return false;
-
   default:
     assert(false && "Cast not implemented");
   }
   llvm_unreachable("Unhandled clang::CastKind enum");
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {

clang/lib/AST/Interp/Opcodes.td

def Neg: Opcode {
   let HasGroup = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Cast.
 //===----------------------------------------------------------------------===//
 // TODO: Expand this to handle casts between more types.
 
-def Sint32TypeClass : TypeClass {
-  let Types = [Sint32];
+def FromCastTypeClass : TypeClass {
+  let Types = [Uint32, Sint32, Bool];
+}
+
+def ToCastTypeClass : TypeClass {
+  let Types = [Uint32, Sint32, Bool];
 }
 
 def Cast: Opcode {
-  let Types = [BoolTypeClass, Sint32TypeClass];
+  let Types = [FromCastTypeClass, ToCastTypeClass];
   let HasGroup = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Comparison opcodes.
 //===----------------------------------------------------------------------===//
 
 class EqualityOpcode : Opcode {

clang/test/AST/Interp/literals.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++11 -verify %s
 // RUN: %clang_cc1 -std=c++11 -verify=ref %s
 
 static_assert(true, "");
 static_assert(false, ""); // expected-error{{failed}} ref-error{{failed}}
 static_assert(nullptr == nullptr, "");
 static_assert(1 == 1, "");
 static_assert(1 == 3, ""); // expected-error{{failed}} ref-error{{failed}}
 
 constexpr int number = 10;
 static_assert(number == 10, "");
 static_assert(number != 10, ""); // expected-error{{failed}} \
                                  // ref-error{{failed}} \
                                  // expected-note{{evaluates to}} \
                                  // ref-note{{evaluates to}}
 
+constexpr bool b = number;
+static_assert(b, "");
+constexpr int one = true;
+static_assert(one == 1, "");
+
+namespace IntegralCasts {
+  constexpr int i = 12;
+  constexpr unsigned int ui = i;
+  static_assert(ui == 12, "");
+  constexpr unsigned int ub = !false;
+  static_assert(ub == 1, "");
+
+  constexpr int si = ui;
+  static_assert(si == 12, "");
+  constexpr int sb = true;
+  static_assert(sb == 1, "");
+
+  constexpr int zero = 0;
+  constexpr unsigned int uzero = 0;
+  constexpr bool bs = i;
+  static_assert(bs, "");
+  constexpr bool bu = ui;
+  static_assert(bu, "");
+  constexpr bool ns = zero;
+  static_assert(!ns, "");
+  constexpr bool nu = uzero;
+  static_assert(!nu, "");
+};
+
+
+
 constexpr bool getTrue() { return true; }
 constexpr bool getFalse() { return false; }
 constexpr void* getNull() { return nullptr; }
 
 constexpr int neg(int m) { return -m; }
 constexpr bool inv(bool b) { return !b; }
 
 static_assert(12, "");