[CIR][CodeGen] Implemented CIR generation for CXXPseudoDestructorExpr (#1753)

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(