[CIR][Lowering] Lower delete array to LLVM (llvm#1588)

Initial implementation  of lowering cir.delete.array llvm#1285 

lowered to a call to **_ZdaPv** keeping similarity with how Clang AST is
lowered.

before 
```LLVM
module @"/opt/tmp/input.cpp" attributes {cir.lang = #cir.lang<cxx>, cir.sob = #cir.signed_overflow_behavior<undefined>, cir.triple = "x86_64-unknown-linux-gnu", cir.type_size_info = #cir.type_size_info<char = 8, int = 32, size_t = 64>, dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i128 = dense<128> : vector<2xi64>, !llvm.ptr<270> = dense<32> : vector<4xi64>, f80 = dense<128> : vector<2xi64>, i1 = dense<8> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, i64 = dense<64> : vector<2xi64>, "dlti.stack_alignment" = 128 : i64, "dlti.endianness" = "little", "dlti.mangling_mode" = "e">} {
  cir.func @_Z17test_delete_arrayPi(%arg0: !cir.ptr<!s32i> loc(fused[#loc3, #loc4])) extra(#fn_attr) {
    %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptr", init] {alignment = 8 : i64} loc(#loc8)
    cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>> loc(#loc5)
    %1 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i> loc(#loc6)
    cir.delete.array %1 : <!s32i> loc(#loc6)
    cir.return loc(#loc2)
  } loc(#loc7)
} loc(#loc)
```

after
```LLVM
define dso_local void @_Z17test_delete_arrayPi(ptr %0) #0 {
  %2 = alloca ptr, i64 1, align 8
  store ptr %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  call void @_ZdaPv(ptr %3)
  ret void
}
```

Author: ahmedshakill

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -3964,6 +3964,26 @@ mlir::LogicalResult CIRToLLVMGetBitfieldOpLowering::matchAndRewrite(
   return mlir::success();
 }
 
+mlir::LogicalResult CIRToLLVMDeleteArrayOpLowering::matchAndRewrite(
+    cir::DeleteArrayOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  StringRef fnName = "_ZdaPv";
+
+  auto voidTy = rewriter.getType<mlir::LLVM::LLVMVoidType>();
+  auto llvmPtrTy = mlir::LLVM::LLVMPointerType::get(rewriter.getContext());
+
+  auto fnTy = mlir::LLVM::LLVMFunctionType::get(voidTy, {llvmPtrTy},
+                                                /*isVarArg=*/false);
+
+  getOrCreateLLVMFuncOp(rewriter, op, fnName, fnTy);
+
+  // Replace the operation with a call to _ZdaPv with the pointer argument
+  rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
+      op, mlir::TypeRange{}, fnName, mlir::ValueRange{adaptor.getAddress()});
+
+  return mlir::success();
+}
+
 mlir::LogicalResult CIRToLLVMIsConstantOpLowering::matchAndRewrite(
     cir::IsConstantOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {
@@ -4345,6 +4365,7 @@ void populateCIRToLLVMConversionPatterns(
       CIRToLLVMGetGlobalOpLowering,
       CIRToLLVMGetMemberOpLowering,
       CIRToLLVMInsertMemberOpLowering,
+      CIRToLLVMDeleteArrayOpLowering,
       CIRToLLVMIsConstantOpLowering,
       CIRToLLVMIsFPClassOpLowering,
       CIRToLLVMLinkerOptionsOpLowering,

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h

@@ -1099,6 +1099,16 @@ class CIRToLLVMGetBitfieldOpLowering
                   mlir::ConversionPatternRewriter &) const override;
 };
 
+class CIRToLLVMDeleteArrayOpLowering
+    : public mlir::OpConversionPattern<cir::DeleteArrayOp> {
+public:
+  using mlir::OpConversionPattern<cir::DeleteArrayOp>::OpConversionPattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(cir::DeleteArrayOp op, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override;
+};
+
 class CIRToLLVMIsConstantOpLowering
     : public mlir::OpConversionPattern<cir::IsConstantOp> {
 public:

clang/test/CIR/Lowering/delete-array.cpp

@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fclangir -emit-llvm -O0 %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+
+void test_delete_array(int *ptr) {
+  delete[] ptr;
+}
+
+// LLVM: [[PTR:%[0-9]+]] = load ptr, ptr %{{[0-9]+}}, align 8
+// LLVM-NEXT: call void @_ZdaPv(ptr [[PTR]])
+
+
+int *newmem();
+struct cls {
+  ~cls();
+};
+cls::~cls() { delete[] newmem(); }
+
+// LLVM: [[NEWMEM:%[0-9]+]] = call ptr @_Z6newmemv()
+// LLVM-NEXT: call void @_ZdaPv(ptr [[NEWMEM]])