[CIR][CodeGen] Implemented CIR generation for CXXPseudoDestructorExpr

Implemented CIR code generation for `CXXPseudoDestructorExpr`. Added a pseudo destructor test to `CIR/CodeGen/dtors.cpp`.

Author: tommymcm

clang/lib/CIR/CodeGen/CIRGenCall.h

@@ -54,7 +54,7 @@ class CIRGenCallee {
  enum class SpecialKind : uintptr_t {
  Invalid,
  Builtin,
- PsuedoDestructor,
+ PseudoDestructor,
  Virtual,
 
  Last = Virtual
@@ -128,8 +128,20 @@ class CIRGenCallee {
  return result;
  }
 
- bool isPsuedoDestructor() const {
- return KindOrFunctionPointer == SpecialKind::PsuedoDestructor;
+ static CIRGenCallee
+ forPseudoDestructor(const clang::CXXPseudoDestructorExpr *expr) {
+ CIRGenCallee result(SpecialKind::PseudoDestructor);
+ result.PseudoDestructorInfo.Expr = expr;
+ return result;
+ }
+
+ bool isPseudoDestructor() const {
+ return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
+ }
+
+ const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
+ assert(isPseudoDestructor());
+ return PseudoDestructorInfo.Expr;
  }
 
  bool isOrdinary() const {

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -576,10 +576,11 @@ CIRGenCallee CIRGenFunction::emitCallee(const clang::Expr *E) {
  emitIgnoredExpr(ME->getBase());
  return emitDirectCallee(CGM, FD);
  }
+ } else if (auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(E)) {
+ return CIRGenCallee::forPseudoDestructor(PDE);
  }
 
  assert(!dyn_cast<SubstNonTypeTemplateParmExpr>(E) && "NYI");
- assert(!dyn_cast<CXXPseudoDestructorExpr>(E) && "NYI");
 
  // Otherwise, we have an indirect reference.
  mlir::Value calleePtr;
@@ -1420,7 +1421,8 @@ RValue CIRGenFunction::emitCallExpr(const clang::CallExpr *E,
  return emitBuiltinExpr(callee.getBuiltinDecl(), callee.getBuiltinID(), E,
  ReturnValue);
 
- assert(!callee.isPsuedoDestructor() && "NYI");
+ if (callee.isPseudoDestructor())
+ return emitCXXPseudoDestructorExpr(callee.getPseudoDestructorExpr());
 
  return emitCall(E->getCallee()->getType(), callee, E, ReturnValue);
 }

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1578,6 +1578,55 @@ RValue CIRGenFunction::emitCXXDestructorCall(GlobalDecl Dtor,
  : getLoc(Dtor.getDecl()->getSourceRange()));
 }
 
+RValue CIRGenFunction::emitCXXPseudoDestructorExpr(
+ const CXXPseudoDestructorExpr *expr) {
+ QualType destroyedType = expr->getDestroyedType();
+ if (destroyedType.hasStrongOrWeakObjCLifetime()) {
+ // Automatic Reference Counting:
+ // If the pseudo-expression names a retainable object with weak or
+ // strong lifetime, the object shall be released.
+ Expr *baseExpr = expr->getBase();
+ Address baseValue = Address::invalid();
+ Qualifiers baseQuals;
+
+ // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
+ if (expr->isArrow()) {
+ baseValue = emitPointerWithAlignment(baseExpr);
+ const auto *ptrTy = baseExpr->getType()->castAs<PointerType>();
+ baseQuals = ptrTy->getPointeeType().getQualifiers();
+ } else {
+ LValue baseLV = emitLValue(baseExpr);
+ baseValue = baseLV.getAddress();
+ QualType baseTy = baseExpr->getType();
+ baseQuals = baseTy.getQualifiers();
+ }
+
+ switch (destroyedType.getObjCLifetime()) {
+ case Qualifiers::OCL_None:
+ case Qualifiers::OCL_ExplicitNone:
+ case Qualifiers::OCL_Autoreleasing:
+ break;
+
+ case Qualifiers::OCL_Strong:
+ llvm_unreachable("NYI, emitArcRelease");
+ break;
+
+ case Qualifiers::OCL_Weak:
+ llvm_unreachable("NYI, emitARCDestroyWeak");
+ break;
+ }
+ } else {
+ // C++ [expr.pseudo]p1:
+ // The result shall only be used as the operand for the function call
+ // operator (), and the result of such a call has type void. The only
+ // effect is the evaluation of the postfix-expression before the dot or
+ // arrow.
+ emitIgnoredExpr(expr->getBase());
+ }
+
+ return RValue::get(nullptr);
+}
+
 /// Emit a call to an operator new or operator delete function, as implicitly
 /// created by new-expressions and delete-expressions.
 static RValue emitNewDeleteCall(CIRGenFunction &CGF,

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -2060,6 +2060,8 @@ class CIRGenFunction : public CIRGenTypeCache {
  const CXXMethodDecl *MD,
  ReturnValueSlot ReturnValue);
 
+ RValue emitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *expr);
+
  void emitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
  Address Ptr);
 

clang/test/CIR/CodeGen/dtors.cpp

@@ -105,6 +105,17 @@ bool bar2() { return foo(1) && foo(2); }
 // CHECK: }) : (!cir.bool) -> !cir.bool
 // CHECK: cir.call @_ZN1XD2Ev
 
+typedef int I;
+void pseudo_dtor() {
+ I x = 10;
+ x.I::~I();
+}
+// CHECK: cir.func dso_local @_Z11pseudo_dtorv()
+// CHECK: %[[INT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>
+// CHECK: %[[TEN:.*]] = cir.const #cir.int<10> : !s32i
+// CHECK: cir.store{{.*}} %[[TEN]], %[[INT]] : !s32i, !cir.ptr<!s32i>
+// CHECK: cir.return
+
 // @B::~B() #1 definition call into base @A::~A()
 // CHECK: cir.func linkonce_odr @_ZN1BD2Ev{{.*}}{
 // CHECK: cir.call @_ZN1AD2Ev(