[CIR][CodeGen] Implemented CXXDeleteExpr (#1756)

Implemented `CXXDeleteExpr` for concrete and virtual destructors.
NYI, global delete, i.e., `::delete`.
Added tests for both destructor types.

Author: tommymcm

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -182,6 +182,11 @@ class CIRGenCXXABI {
   virtual void registerGlobalDtor(CIRGenFunction &CGF, const VarDecl *D,
                                   cir::FuncOp dtor, mlir::Value Addr) = 0;
 
+  virtual void emitVirtualObjectDelete(CIRGenFunction &CGF,
+                                       const CXXDeleteExpr *DE, Address Ptr,
+                                       QualType ElementType,
+                                       const CXXDestructorDecl *Dtor) = 0;
+
   virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
                                       FunctionArgList &Args) const = 0;
 
@@ -212,6 +217,15 @@ class CIRGenCXXABI {
   virtual void emitVTableDefinitions(CIRGenVTables &CGVT,
                                      const CXXRecordDecl *RD) = 0;
 
+  using DeleteOrMemberCallExpr =
+      llvm::PointerUnion<const CXXDeleteExpr *, const CXXMemberCallExpr *>;
+
+  virtual mlir::Value emitVirtualDestructorCall(CIRGenFunction &CGF,
+                                                const CXXDestructorDecl *Dtor,
+                                                CXXDtorType DtorType,
+                                                Address This,
+                                                DeleteOrMemberCallExpr E) = 0;
+
   /// Emit any tables needed to implement virtual inheritance.  For Itanium,
   /// this emits virtual table tables.
   virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD) = 0;

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1227,7 +1227,8 @@ static bool EmitObjectDelete(CIRGenFunction &CGF, const CXXDeleteExpr *DE,
           }
         }
         if (UseVirtualCall) {
-          llvm_unreachable("NYI");
+          CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
+                                                      Dtor);
           return false;
         }
       }
@@ -1241,7 +1242,9 @@ static bool EmitObjectDelete(CIRGenFunction &CGF, const CXXDeleteExpr *DE,
       NormalAndEHCleanup, Ptr.getPointer(), OperatorDelete, ElementType);
 
   if (Dtor) {
-    llvm_unreachable("NYI");
+    CGF.emitCXXDestructorCall(Dtor, Dtor_Complete,
+                              /*ForVirtualBase=*/false,
+                              /*Delegating=*/false, Ptr, ElementType);
   } else if (auto Lifetime = ElementType.getObjCLifetime()) {
     switch (Lifetime) {
     case Qualifiers::OCL_None:

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -187,6 +187,9 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
                           QualType ThisTy) override;
   void registerGlobalDtor(CIRGenFunction &CGF, const VarDecl *D,
                           cir::FuncOp dtor, mlir::Value Addr) override;
+  void emitVirtualObjectDelete(CIRGenFunction &CGF, const CXXDeleteExpr *DE,
+                               Address Ptr, QualType ElementType,
+                               const CXXDestructorDecl *Dtor) override;
   virtual void emitRethrow(CIRGenFunction &CGF, bool isNoReturn) override;
   virtual void emitThrow(CIRGenFunction &CGF, const CXXThrowExpr *E) override;
   CatchTypeInfo
@@ -205,6 +208,10 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
   CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &CGF, GlobalDecl GD,
                                          Address This, mlir::Type Ty,
                                          SourceLocation Loc) override;
+  mlir::Value emitVirtualDestructorCall(CIRGenFunction &CGF,
+                                        const CXXDestructorDecl *Dtor,
+                                        CXXDtorType DtorType, Address This,
+                                        DeleteOrMemberCallExpr E) override;
   mlir::Value getVTableAddressPoint(BaseSubobject Base,
                                     const CXXRecordDecl *VTableClass) override;
   mlir::Value getVTableAddressPointInStructorWithVTT(
@@ -2187,6 +2194,32 @@ void CIRGenItaniumCXXABI::emitVTableDefinitions(CIRGenVTables &CGVT,
     llvm_unreachable("NYI");
 }
 
+mlir::Value CIRGenItaniumCXXABI::emitVirtualDestructorCall(
+    CIRGenFunction &CGF, const CXXDestructorDecl *dtor, CXXDtorType dtorType,
+    Address thisAddr, DeleteOrMemberCallExpr expr) {
+  auto *callExpr = dyn_cast<const CXXMemberCallExpr *>(expr);
+  auto *delExpr = dyn_cast<const CXXDeleteExpr *>(expr);
+  assert((callExpr != nullptr) ^ (delExpr != nullptr));
+  assert(callExpr == nullptr || callExpr->arg_begin() == callExpr->arg_end());
+  assert(dtorType == Dtor_Deleting || dtorType == Dtor_Complete);
+
+  GlobalDecl globalDecl(dtor, dtorType);
+  const CIRGenFunctionInfo *fnInfo =
+      &CGM.getTypes().arrangeCXXStructorDeclaration(globalDecl);
+  auto fnTy = CGF.CGM.getTypes().GetFunctionType(*fnInfo);
+  auto callee = CIRGenCallee::forVirtual(callExpr, globalDecl, thisAddr, fnTy);
+
+  QualType thisTy;
+  if (callExpr)
+    thisTy = callExpr->getObjectType();
+  else
+    thisTy = delExpr->getDestroyedType();
+
+  CGF.emitCXXDestructorCall(globalDecl, callee, thisAddr.emitRawPointer(),
+                            thisTy, nullptr, QualType(), nullptr);
+  return nullptr;
+}
+
 void CIRGenItaniumCXXABI::emitVirtualInheritanceTables(
     const CXXRecordDecl *RD) {
   CIRGenVTables &VTables = CGM.getVTables();
@@ -2717,6 +2750,22 @@ bool CIRGenItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
   return MPT->isMemberFunctionPointer();
 }
 
+/// The Itanium ABI always places an offset to the complete object
+/// at entry -2 in the vtable.
+void CIRGenItaniumCXXABI::emitVirtualObjectDelete(
+    CIRGenFunction &CGF, const CXXDeleteExpr *delExpr, Address ptr,
+    QualType elementType, const CXXDestructorDecl *dtor) {
+  bool useGlobalDelete = delExpr->isGlobalDelete();
+  if (useGlobalDelete)
+    llvm_unreachable("NYI");
+
+  CXXDtorType dtorType = useGlobalDelete ? Dtor_Complete : Dtor_Deleting;
+  emitVirtualDestructorCall(CGF, dtor, dtorType, ptr, delExpr);
+
+  if (useGlobalDelete)
+    llvm_unreachable("NYI");
+}
+
 /************************** Array allocation cookies **************************/
 
 CharUnits CIRGenItaniumCXXABI::getArrayCookieSizeImpl(QualType ElementType) {

clang/test/CIR/CodeGen/delete.cpp

@@ -13,3 +13,38 @@ namespace test1 {
   // CHECK: %[[CONST:.*]] = cir.const #cir.int<4> : !u64i
   // CHECK: cir.call @_ZN5test11AdlEPvm({{.*}}, %[[CONST]])
 }
+
+namespace test2 {
+  struct A {
+    ~A() {}
+  };
+  struct B {
+    A *a;
+    ~B();
+  };
+    // CHECK-LABEL: cir.func{{.*}} @_ZN5test21BD2Ev
+    // CHECK:         cir.call @_ZN5test21AD2Ev
+    // CHECK:         cir.call @_ZdlPvm
+    // CHECK:         cir.return
+    B::~B() { delete a; }
+}
+
+namespace test3 {
+  struct X {
+    virtual ~X();
+  };
+
+// Calling delete with a virtual destructor.
+// CHECK-LABEL:   cir.func dso_local @_ZN5test37destroyEPNS_1XE
+// CHECK:           %[[ARG_VAR:.*]] = cir.alloca !cir.ptr<!rec_test33A3AX>
+// CHECK:           %[[ARG:.*]] = cir.load{{.*}} %[[ARG_VAR]] : !cir.ptr<!cir.ptr<!rec_test33A3AX>>, !cir.ptr<!rec_test33A3AX>
+// CHECK:           %[[ARG_PTR:.*]] = cir.cast(bitcast, %[[ARG]]
+// CHECK:           %[[VTABLE:.*]] = cir.load{{.*}} %[[ARG_PTR]]
+// CHECK:           %[[DTOR_PTR:.*]] = cir.vtable.address_point( %[[VTABLE]] : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_test33A3AX>)>>>, address_point = <index = 0, offset = 1>)
+// CHECK:           %[[DTOR_FUN:.*]] = cir.load{{.*}} %[[DTOR_PTR]]
+// CHECK:           cir.call %[[DTOR_FUN]](%[[ARG]])
+// CHECK:           cir.return
+  void destroy(X *x) {
+    delete x;
+  }
+}