[clang][Interp] IntegralComplexToBoolean casts

[tbaeder]

Summary

I wanted to avoid adding too many opcodes for bitint, complex, vector, etc. types so I implemented this by just emitting more ops.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1165

Since complex types are arrays with two elements, we can't dereference them like normal. This change just ignore the dereference.

I was wondering if it would be better to add an opcode to dereference it so we have [real, imag] on the stack and then callers that operate on such complex rvalues can pop(); pop(); to get the values.

[aaron.ballman]

LGTM aside from a minor cleanup.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1165

I was wondering if it would be better to add an opcode to dereference it so we have [real, imag] on the stack and then callers that operate on such complex rvalues can pop(); pop(); to get the values.

That might be worthwhile as an optimization, but I suppose we can wait to see how often complex is used in constant expressions before deciding what to do there?

clang/lib/AST/Interp/ByteCodeExprGen.h

272–275

This form does the assertion for you.

clang/lib/AST/Interp/ByteCodeExprGen.h

llvm::RoundingMode getRoundingMode(const Expr *E) const {
     FPOptions FPO = E->getFPFeaturesInEffect(Ctx.getLangOpts());
 
     if (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic)
       return llvm::RoundingMode::NearestTiesToEven;
 
     return FPO.getRoundingMode();
   }
 
+  std::optional<PrimType> classifyComplexElementType(QualType T) const {
+    assert(T->isAnyComplexType());
+
+    QualType ElemType = T->getAs<ComplexType>()->getElementType();
+
+    return this->classify(ElemType);
+  }
+
   bool emitRecordDestruction(const Descriptor *Desc);
   bool emitDerivedToBaseCasts(const RecordType *DerivedType,
                               const RecordType *BaseType, const Expr *E);
   bool emitBuiltinBitCast(const CastExpr *E);
 
 protected:
   /// Variable to storage mapping.
   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;

clang/lib/AST/Interp/ByteCodeExprGen.cpp

case CK_IntegralCast: {
 
     if (!this->visit(SubExpr))
       return false;
 
     // TODO: Emit this only if FromT != ToT.
     return this->emitCast(*FromT, *ToT, CE);
   }
 
+  case CK_IntegralComplexToBoolean: {
+    std::optional<PrimType> ElemT =
+        classifyComplexElementType(SubExpr->getType());
+    if (!ElemT)
+      return false;
+    // We emit the expression (__real(E) != 0 || __imag(E) != 0)
+    // for us, that means (bool)E[0] || (bool)E[1]
+    if (!this->visit(SubExpr))
+      return false;
+    if (!this->emitConstUint8(0, CE))
+      return false;
+    if (!this->emitArrayElemPtrUint8(CE))
+      return false;
+    if (!this->emitLoadPop(*ElemT, CE))
+      return false;
+    if (!this->emitCast(*ElemT, PT_Bool, CE))
+      return false;
+    // We now have the bool value of E[0] on the stack.
+    LabelTy LabelTrue = this->getLabel();
+    if (!this->jumpTrue(LabelTrue))
+      return false;
+
+    if (!this->emitConstUint8(1, CE))
+      return false;
+    if (!this->emitArrayElemPtrPopUint8(CE))
+      return false;
+    if (!this->emitLoadPop(*ElemT, CE))
+      return false;
+    if (!this->emitCast(*ElemT, PT_Bool, CE))
+      return false;
+    // Leave the boolean value of E[1] on the stack.
+    LabelTy EndLabel = this->getLabel();
+    this->jump(EndLabel);
+
+    this->emitLabel(LabelTrue);
+    if (!this->emitPopPtr(CE))
+      return false;
+    if (!this->emitConstBool(true, CE))
+      return false;
+
+    this->fallthrough(EndLabel);
+    this->emitLabel(EndLabel);
+
+    return true;
+  }
+
   case CK_ToVoid:
     return discard(SubExpr);
 
   default:
     assert(false && "Cast not implemented");
   }
   llvm_unreachable("Unhandled clang::CastKind enum");
 }
if (!LV->refersToBitField()) {
       }
     }
 
     if (!visit(LV))
       return false;
     return Indirect(*T);
   }
 
+  if (LV->getType()->isAnyComplexType())
+    return visit(LV);
+
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereferenceParam(
     const Expr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
     llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {

clang/test/AST/Interp/complex.cpp

 static_assert(__real(D2) == 12, "");
 static_assert(__imag(D2) == 12, "");
 
 constexpr _Complex int I3 = {15};
 static_assert(__real(I3) == 15, "");
 static_assert(__imag(I3) == 15, "");
 #endif
 
-
-
-
 /// FIXME: This should work in the new interpreter as well.
 // constexpr _Complex _BitInt(8) A = 0;// = {4};
+
+namespace CastToBool {
+  constexpr _Complex int F = {0, 1};
+  static_assert(F, "");
+  constexpr _Complex int F2 = {1, 0};
+  static_assert(F2, "");
+  constexpr _Complex int F3 = {0, 0};
+  static_assert(!F3, "");
+
+  constexpr _Complex unsigned char F4 = {0, 1};
+  static_assert(F4, "");
+  constexpr _Complex unsigned char F5 = {1, 0};
+  static_assert(F5, "");
+  constexpr _Complex unsigned char F6 = {0, 0};
+  static_assert(!F6, "");
+}