TheRock/compiler/amd-llvm/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp

// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fcxx-exceptions -fexceptions -fclangir -emit-cir -mmlir -mlir-print-ir-after=cir-cxxabi-lowering -mmlir -mlir-print-ir-before=cir-cxxabi-lowering -mmlir -mlir-print-ir-after=cir-cxxabi-lowering %s -o %t.cir 2> %t-cxxabi.cir
// RUN: FileCheck --input-file=%t-cxxabi.cir --check-prefix=CIR-BEFORE-CXXABI %s
// RUN: FileCheck --input-file=%t-cxxabi.cir --check-prefix=CIR-AFTER-CXXABI %s
// RUN: FileCheck --input-file=%t.cir --check-prefix=CIR %s
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fcxx-exceptions -fexceptions -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll --check-prefix=LLVM %s
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fcxx-exceptions -fexceptions -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll --check-prefix=OGCG %s

struct ThrowingDtor {
  ~ThrowingDtor() noexcept(false);
  int x;
};

void test_delete_array_throwing_dtor(ThrowingDtor *ptr) {
  delete[] ptr;
}

// CIR-BEFORE-CXXABI: IR Dump Before CXXABILowering: cir-cxxabi-lowering

// CIR-BEFORE-CXXABI: cir.func {{.*}} @_Z31test_delete_array_throwing_dtorP12ThrowingDtor
// CIR-BEFORE-CXXABI:   %[[PTR:.*]] = cir.load
// CIR-BEFORE-CXXABI:   %[[NULL:.*]] = cir.const #cir.ptr<null>
// CIR-BEFORE-CXXABI:   %[[NOT_NULL:.*]] = cir.cmp ne %[[PTR]], %[[NULL]]
// CIR-BEFORE-CXXABI:   cir.if %[[NOT_NULL]] {
// CIR-BEFORE-CXXABI:     cir.delete_array %[[PTR]] : !cir.ptr<!rec_ThrowingDtor> dtor_may_throw {delete_fn = @_ZdaPvm, delete_params = #cir.usual_delete_params<size = true>, element_dtor = @_ZN12ThrowingDtorD1Ev}
// CIR-BEFORE-CXXABI:   }

// CIR-AFTER-CXXABI: IR Dump After CXXABILowering: cir-cxxabi-lowering

// CIR-AFTER-CXXABI: cir.func {{.*}} @_Z31test_delete_array_throwing_dtorP12ThrowingDtor
// CIR-AFTER-CXXABI:   %[[PTR:.*]] = cir.load
// CIR-AFTER-CXXABI:   %[[NULL:.*]] = cir.const #cir.ptr<null>
// CIR-AFTER-CXXABI:   %[[NOT_NULL:.*]] = cir.cmp ne %[[PTR]], %[[NULL]]
// CIR-AFTER-CXXABI:   cir.if %[[NOT_NULL]] {
// CIR-AFTER-CXXABI:     cir.cleanup.scope {
// CIR-AFTER-CXXABI:       cir.array.dtor %{{.*}}, %{{.*}} : !cir.ptr<!rec_ThrowingDtor>, !u64i dtor_may_throw {
// CIR-AFTER-CXXABI:         cir.call @_ZN12ThrowingDtorD1Ev({{.*}})
// CIR-AFTER-CXXABI-NOT:     nothrow
// CIR-AFTER-CXXABI:       }
// CIR-AFTER-CXXABI:     } cleanup all {
// CIR-AFTER-CXXABI:       cir.call @_ZdaPvm({{.*}}) nothrow
// CIR-AFTER-CXXABI:     }
// CIR-AFTER-CXXABI:   }

// CIR: cir.func {{.*}} @_Z31test_delete_array_throwing_dtorP12ThrowingDtor
// CIR:   %[[PTR:.*]] = cir.load
// CIR:   cir.if
//
// CIR:     %[[BYTE_PTR:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!rec_ThrowingDtor> -> !cir.ptr<!u8i>
// CIR:     %[[NEG_COOKIE:.*]] = cir.const #cir.int<-8> : !s64i
// CIR:     %[[ALLOC_BYTE_PTR:.*]] = cir.ptr_stride %[[BYTE_PTR]], %[[NEG_COOKIE]]
// CIR:     %[[VOID_PTR:.*]] = cir.cast bitcast %[[ALLOC_BYTE_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
// CIR:     %[[COOKIE_PTR:.*]] = cir.cast bitcast %[[ALLOC_BYTE_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!u64i>
// CIR:     %[[NUM_ELEM:.*]] = cir.load{{.*}} %[[COOKIE_PTR]]
//
// CIR:     cir.cleanup.scope {
// CIR:       %[[END:.*]] = cir.ptr_stride %[[PTR]], %[[NUM_ELEM]]
// CIR:       %[[NOT_EMPTY:.*]] = cir.cmp ne %[[END]], %[[PTR]]
// CIR:       cir.if %[[NOT_EMPTY]] {
// CIR:         %[[ARR_IDX:.*]] = cir.alloca {{.*}} ["__array_idx"]
// CIR:         cir.store %[[END]], %[[ARR_IDX]]
//
// CIR:         cir.cleanup.scope {
// CIR:           cir.do {
// CIR:             %[[CUR:.*]] = cir.load %[[ARR_IDX]]
// CIR:             %[[STRIDE_M1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:             %[[PREV:.*]] = cir.ptr_stride %[[CUR]], %[[STRIDE_M1]]
// CIR:             cir.store %[[PREV]], %[[ARR_IDX]]
// CIR:             cir.call @_ZN12ThrowingDtorD1Ev(%[[PREV]])
// CIR-NOT:           nothrow
// CIR:             cir.yield
// CIR:           } while {
// CIR:             %[[CUR2:.*]] = cir.load %[[ARR_IDX]]
// CIR:             %[[CMP:.*]] = cir.cmp ne %[[CUR2]], %[[PTR]]
// CIR:             cir.condition(%[[CMP]])
// CIR:           }
// CIR:           cir.yield
// CIR:         } cleanup eh {
// CIR:           %[[CL_CUR:.*]] = cir.load %[[ARR_IDX]]
// CIR:           %[[CL_NEMPTY:.*]] = cir.cmp ne %[[CL_CUR]], %[[PTR]]
// CIR:           cir.if %[[CL_NEMPTY]] {
// CIR:             cir.do {
// CIR:               %[[CL_E:.*]] = cir.load %[[ARR_IDX]]
// CIR:               %[[CL_M1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:               %[[CL_PREV:.*]] = cir.ptr_stride %[[CL_E]], %[[CL_M1]]
// CIR:               cir.store %[[CL_PREV]], %[[ARR_IDX]]
// CIR:               cir.call @_ZN12ThrowingDtorD1Ev(%[[CL_PREV]])
// CIR-NOT:             nothrow
// CIR:             } while {
// CIR:             }
// CIR:           }
// CIR:           cir.yield
// CIR:         }
// CIR:       }
// CIR:       cir.yield
// CIR:     } cleanup all {
// CIR:       %[[ELEM_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR:       %[[ARRAY_SIZE:.*]] = cir.mul %[[ELEM_SIZE]], %[[NUM_ELEM]]
// CIR:       %[[COOKIE_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR:       %[[TOTAL_SIZE:.*]] = cir.add %[[ARRAY_SIZE]], %[[COOKIE_SIZE]]
// CIR:       cir.call @_ZdaPvm(%[[VOID_PTR]], %[[TOTAL_SIZE]]) nothrow
// CIR:       cir.yield
// CIR:     }
// CIR:   }

// LLVM: define {{.*}} void @_Z31test_delete_array_throwing_dtorP12ThrowingDtor(ptr {{.*}})
//
// `__array_idx` alloca and the function-entry null check.
// LLVM:   %[[ARR_IDX:[0-9]+]] = alloca ptr
// LLVM:   %[[PTR:.*]] = load ptr
// LLVM:   %[[NOT_NULL:.*]] = icmp ne ptr %[[PTR]], null
// LLVM:   br i1 %[[NOT_NULL]], label %[[NOTNULL:[^,]+]], label %{{.*}}
//
// Cookie read and is-empty check.
// LLVM: [[NOTNULL]]:
// LLVM:   %[[ALLOC_PTR:.*]] = getelementptr i8, ptr %[[PTR]], i64 -8
// LLVM:   %[[NUM_ELEM:.*]] = load i64, ptr %[[ALLOC_PTR]]
// LLVM:   %[[ARR_END:.*]] = getelementptr %struct.ThrowingDtor, ptr %[[PTR]], i64 %[[NUM_ELEM]]
// LLVM:   %[[NOT_EMPTY:.*]] = icmp ne ptr %[[ARR_END]], %[[PTR]]
// LLVM:   br i1 %[[NOT_EMPTY]], label %[[DESTROY:[^,]+]], label %[[CALL_DELETE_NORMAL:[^ ]+]]
//
// Body loop entry: seed __array_idx with arrayEnd and fall through into the
// body. (FlattenCFG emits an empty trampoline block between the entry
// store and the body, which we skip with `{{.*}}`.)
// LLVM: [[DESTROY]]:
// LLVM:   store ptr %[[ARR_END]], ptr %[[ARR_IDX]]
// LLVM:   br label %{{.*}}
//
// Body do-while condition block: load __array_idx, compare to begin, branch
// back to the body or out to the body-loop exit.
// LLVM:   %[[BODY_CUR:.*]] = load ptr, ptr %[[ARR_IDX]]
// LLVM:   %[[BODY_CMP:.*]] = icmp ne ptr %[[BODY_CUR]], %[[PTR]]
// LLVM:   br i1 %[[BODY_CMP]], label %[[BODY:[^,]+]], label %[[BODY_EXIT:[^ ]+]]
//
// Body do-while body: load current, compute prev = current - 1, store prev
// back to __array_idx, invoke dtor(prev). On unwind, go to LPAD.
// LLVM: [[BODY]]:
// LLVM:   %[[BODY_LOAD:.*]] = load ptr, ptr %[[ARR_IDX]]
// LLVM:   %[[BODY_PREV:.*]] = getelementptr %struct.ThrowingDtor, ptr %[[BODY_LOAD]], i64 -1
// LLVM:   store ptr %[[BODY_PREV]], ptr %[[ARR_IDX]]
// LLVM:   invoke void @_ZN12ThrowingDtorD1Ev(ptr %[[BODY_PREV]])
// LLVM:           to label %{{.*}} unwind label %[[LPAD:[^ ]+]]
//
// Cleanup landing pad: cleanup landingpad, save exn/sel, then check whether
// any elements remain to destroy. (FlattenCFG emits a trampoline block
// from the landingpad to the phi-of-exn/sel and the empty-check branch.)
// LLVM: [[LPAD]]:
// LLVM:   %[[LPAD_VAL:.*]] = landingpad { ptr, i32 }
// LLVM:           cleanup
// LLVM:   %[[LPAD_EXN:.*]] = extractvalue { ptr, i32 } %[[LPAD_VAL]], 0
// LLVM:   %[[LPAD_SEL:.*]] = extractvalue { ptr, i32 } %[[LPAD_VAL]], 1
// LLVM:   br label %{{.*}}
//
// LPAD continuation: phi the exn/sel forward, load __array_idx, check for
// empty, and branch into the cleanup loop or to the EH-side delete.
// LLVM:   phi ptr [ %[[LPAD_EXN]], %{{.*}} ]
// LLVM:   phi i32 [ %[[LPAD_SEL]], %{{.*}} ]
// LLVM:   %[[CL_INIT_CUR:.*]] = load ptr, ptr %[[ARR_IDX]]
// LLVM:   %[[CL_NEMPTY:.*]] = icmp ne ptr %[[CL_INIT_CUR]], %[[PTR]]
// LLVM:   br i1 %[[CL_NEMPTY]], label %{{.*}}, label %{{.*}}
//
// Cleanup do-while condition block: load __array_idx (which the body
// already pointed at the element that threw, so the cleanup picks up at
// prev = element-that-threw - 1), compare to begin, branch into the
// cleanup body or out to the EH-side delete.
// LLVM:   %[[CL_CUR:.*]] = load ptr, ptr %[[ARR_IDX]]
// LLVM:   %[[CL_CMP:.*]] = icmp ne ptr %[[CL_CUR]], %[[PTR]]
// LLVM:   br i1 %[[CL_CMP]], label %[[CL_BODY:[^,]+]], label %{{.*}}
//
// Cleanup do-while body: load current, decrement, store back, invoke
// dtor(prev). On a *second* throw, unwind to terminate.lpad.
// LLVM: [[CL_BODY]]:
// LLVM:   %[[CL_LOAD:.*]] = load ptr, ptr %[[ARR_IDX]]
// LLVM:   %[[CL_PREV:.*]] = getelementptr %struct.ThrowingDtor, ptr %[[CL_LOAD]], i64 -1
// LLVM:   store ptr %[[CL_PREV]], ptr %[[ARR_IDX]]
// LLVM:   invoke void @_ZN12ThrowingDtorD1Ev(ptr %[[CL_PREV]])
// LLVM:           to label %{{.*}} unwind label %[[TERMINATE_LPAD:[^ ]+]]
//
// Terminate landing pad: catch-all + `__clang_call_terminate`.
// LLVM: [[TERMINATE_LPAD]]:
// LLVM:   landingpad { ptr, i32 }
// LLVM:           catch ptr null
// LLVM:   call void @__clang_call_terminate(ptr %{{.*}})
// LLVM:   unreachable
//
// Normal path: compute total size, call `_ZdaPvm`. Mirrors OGCG's
// `arraydestroy.done8` block.
// LLVM: [[CALL_DELETE_NORMAL]]:
// LLVM:   %[[NORMAL_ARRAY_SIZE:.*]] = mul i64 4, %[[NUM_ELEM]]
// LLVM:   %[[NORMAL_TOTAL_SIZE:.*]] = add i64 %[[NORMAL_ARRAY_SIZE]], 8
// LLVM:   call void @_ZdaPvm(ptr %[[ALLOC_PTR]], i64 %[[NORMAL_TOTAL_SIZE]])
//
// EH-side delete + resume: the exn/sel are PHI'd one more time as
// FlattenCFG joins the cleanup-loop exit blocks; then total size is
// computed, `_ZdaPvm` is called, and the original exception is resumed.
// Mirrors OGCG's `arraydestroy.done6` -> `eh.resume` chain.
// LLVM:   %[[RESUME_EXN:.*]] = phi ptr [ %{{.*}}, %{{.*}} ]
// LLVM:   %[[RESUME_SEL:.*]] = phi i32 [ %{{.*}}, %{{.*}} ]
// LLVM:   %[[EH_ARRAY_SIZE:.*]] = mul i64 4, %[[NUM_ELEM]]
// LLVM:   %[[EH_TOTAL_SIZE:.*]] = add i64 %[[EH_ARRAY_SIZE]], 8
// LLVM:   call void @_ZdaPvm(ptr %[[ALLOC_PTR]], i64 %[[EH_TOTAL_SIZE]])
// LLVM:   %[[RESUME_VAL:.*]] = insertvalue { ptr, i32 } poison, ptr %[[RESUME_EXN]], 0
// LLVM:   %[[RESUME_VAL2:.*]] = insertvalue { ptr, i32 } %[[RESUME_VAL]], i32 %[[RESUME_SEL]], 1
// LLVM:   resume { ptr, i32 } %[[RESUME_VAL2]]

// OGCG: define {{.*}} void @_Z31test_delete_array_throwing_dtorP12ThrowingDtor(ptr {{.*}})
//
// Function entry and null check.
// OGCG:   %[[PTR:.*]] = load ptr, ptr %{{.*}}
// OGCG:   %[[ISNULL:.*]] = icmp eq ptr %[[PTR]], null
// OGCG:   br i1 %[[ISNULL]], label %[[DELETE_END:[^,]+]], label %[[DELETE_NOTNULL:[^ ]+]]
//
// Cookie read + is-empty check.
// OGCG: [[DELETE_NOTNULL]]:
// OGCG:   %[[ALLOC_PTR:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i64 -8
// OGCG:   %[[NUM_ELEM:.*]] = load i64, ptr %[[ALLOC_PTR]]
// OGCG:   %[[ARR_END:.*]] = getelementptr inbounds %struct.ThrowingDtor, ptr %[[PTR]], i64 %[[NUM_ELEM]]
// OGCG:   %[[ISEMPTY:.*]] = icmp eq ptr %[[PTR]], %[[ARR_END]]
// OGCG:   br i1 %[[ISEMPTY]], label %[[DONE8:[^,]+]], label %[[BODY:[^ ]+]]
//
// Body loop: phi-based reverse iteration.
// OGCG: [[BODY]]:
// OGCG:   %[[ELT_PAST:.*]] = phi ptr [ %[[ARR_END]], %[[DELETE_NOTNULL]] ], [ %[[ELT:.*]], %[[INV_CONT:[^ ]+]] ]
// OGCG:   %[[ELT]] = getelementptr inbounds %struct.ThrowingDtor, ptr %[[ELT_PAST]], i64 -1
// OGCG:   invoke void @_ZN12ThrowingDtorD1Ev(ptr {{.*}}%[[ELT]])
// OGCG:           to label %[[INV_CONT]] unwind label %[[LPAD:[^ ]+]]
//
// OGCG: [[INV_CONT]]:
// OGCG:   %[[BODY_DONE:.*]] = icmp eq ptr %[[ELT]], %[[PTR]]
// OGCG:   br i1 %[[BODY_DONE]], label %[[DONE8]], label %[[BODY]]
//
// Normal path: compute size, call `_ZdaPvm`, fall through.
// OGCG: [[DONE8]]:
// OGCG:   %[[NORMAL_ARRAY_SIZE:.*]] = mul i64 4, %[[NUM_ELEM]]
// OGCG:   %[[NORMAL_TOTAL_SIZE:.*]] = add i64 %[[NORMAL_ARRAY_SIZE]], 8
// OGCG:   call void @_ZdaPvm(ptr {{.*}}%[[ALLOC_PTR]], i64 {{.*}}%[[NORMAL_TOTAL_SIZE]])
// OGCG:   br label %[[DELETE_END]]
//
// OGCG: [[DELETE_END]]:
// OGCG:   ret void
//
// Cleanup landing pad: cleanup landingpad, save exn/sel, then check whether
// any elements remain to destroy.
// OGCG: [[LPAD]]:
// OGCG:   %[[LPAD_VAL:.*]] = landingpad { ptr, i32 }
// OGCG:           cleanup
// OGCG:   %[[CL_ISEMPTY:.*]] = icmp eq ptr %[[PTR]], %[[ELT]]
// OGCG:   br i1 %[[CL_ISEMPTY]], label %[[DONE6:[^,]+]], label %[[BODY2:[^ ]+]]
//
// Cleanup loop: phi starts at the element that threw, decrements to the
// previous element, invokes dtor unwinding to terminate.lpad on a second
// throw.
// OGCG: [[BODY2]]:
// OGCG:   %[[ELT_PAST3:.*]] = phi ptr [ %[[ELT]], %[[LPAD]] ], [ %[[ELT4:.*]], %[[INV_CONT5:[^ ]+]] ]
// OGCG:   %[[ELT4]] = getelementptr inbounds %struct.ThrowingDtor, ptr %[[ELT_PAST3]], i64 -1
// OGCG:   invoke void @_ZN12ThrowingDtorD1Ev(ptr {{.*}}%[[ELT4]])
// OGCG:           to label %[[INV_CONT5]] unwind label %[[TERMINATE_LPAD:[^ ]+]]
//
// OGCG: [[INV_CONT5]]:
// OGCG:   %[[CL_DONE:.*]] = icmp eq ptr %[[ELT4]], %[[PTR]]
// OGCG:   br i1 %[[CL_DONE]], label %[[DONE6]], label %[[BODY2]]
//
// EH path: compute size, call `_ZdaPvm`, resume.
// OGCG: [[DONE6]]:
// OGCG:   %[[EH_ARRAY_SIZE:.*]] = mul i64 4, %[[NUM_ELEM]]
// OGCG:   %[[EH_TOTAL_SIZE:.*]] = add i64 %[[EH_ARRAY_SIZE]], 8
// OGCG:   call void @_ZdaPvm(ptr {{.*}}%[[ALLOC_PTR]], i64 {{.*}}%[[EH_TOTAL_SIZE]])
// OGCG:   br label %[[EH_RESUME:[^ ]+]]
//
// OGCG: [[EH_RESUME]]:
// OGCG:   resume { ptr, i32 }
//
// Terminate landing pad.
// OGCG: [[TERMINATE_LPAD]]:
// OGCG:   landingpad { ptr, i32 }
// OGCG:           catch ptr null
// OGCG:   call void @__clang_call_terminate(ptr {{.*}})
// OGCG:   unreachable