[clang][bytecode] Only booleans can be inverted

No need to have the Inv() function be templated.

Author: tbaederr

clang/lib/AST/ByteCode/Boolean.h

@@ -44,6 +44,7 @@ class Boolean final {
   Boolean operator-() const { return Boolean(V); }
   Boolean operator-(const Boolean &Other) const { return Boolean(V - Other.V); }
   Boolean operator~() const { return Boolean(true); }
+  Boolean operator!() const { return Boolean(!V); }
 
   template <typename Ty, typename = std::enable_if_t<std::is_integral_v<Ty>>>
   explicit operator Ty() const {

clang/lib/AST/ByteCode/Compiler.cpp

@@ -5112,7 +5112,7 @@ bool Compiler<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
     if (!this->visitBool(SubExpr))
       return false;
 
-    if (!this->emitInvBool(E))
+    if (!this->emitInv(E))
       return false;
 
     if (PrimType ET = classifyPrim(E->getType()); ET != PT_Bool)
@@ -5231,7 +5231,7 @@ bool Compiler<Emitter>::VisitComplexUnaryOperator(const UnaryOperator *E) {
       return false;
     if (!this->emitComplexBoolCast(SubExpr))
       return false;
-    if (!this->emitInvBool(E))
+    if (!this->emitInv(E))
       return false;
     if (PrimType ET = classifyPrim(E->getType()); ET != PT_Bool)
       return this->emitCast(PT_Bool, ET, E);

clang/lib/AST/ByteCode/Interp.h

@@ -656,15 +656,9 @@ inline bool Divf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
 // Inv
 //===----------------------------------------------------------------------===//
 
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool Inv(InterpState &S, CodePtr OpPC) {
-  using BoolT = PrimConv<PT_Bool>::T;
-  const T &Val = S.Stk.pop<T>();
-  const unsigned Bits = Val.bitWidth();
-  Boolean R;
-  Boolean::inv(BoolT::from(Val, Bits), &R);
-
-  S.Stk.push<BoolT>(R);
+inline bool Inv(InterpState &S, CodePtr OpPC) {
+  const auto &Val = S.Stk.pop<Boolean>();
+  S.Stk.push<Boolean>(!Val);
   return true;
 }
 

clang/lib/AST/ByteCode/Opcodes.td

@@ -103,10 +103,6 @@ def PtrTypeClass : TypeClass {
   let Types = [Ptr, FnPtr, MemberPtr];
 }
 
-def BoolTypeClass : TypeClass {
-  let Types = [Bool];
-}
-
 def NonPtrTypeClass : TypeClass {
   let Types = !listconcat(IntegerTypeClass.Types, [Bool], [Float]);
 }
@@ -574,11 +570,8 @@ def Shr : Opcode {
 // Unary operators.
 //===----------------------------------------------------------------------===//
 
-// [Real] -> [Real]
-def Inv: Opcode {
-  let Types = [BoolTypeClass];
-  let HasGroup = 1;
-}
+// [Bool] -> [Bool]
+def Inv: Opcode;
 
 // Increment and decrement.
 def Inc: AluOpcode;