// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -fexceptions -fcxx-exceptions -emit-cir -mmlir --mlir-print-ir-before=cir-lowering-prepare %s -o %t.cir  2> %t-before-lp.cir
// RUN: FileCheck --input-file=%t-before-lp.cir %s -check-prefix=CIR-BEFORE-LPP
// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fexceptions -fcxx-exceptions -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fexceptions -fcxx-exceptions -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG

struct S {
    S();
    ~S();
};

void test_partial_array_cleanup() {
    S s[4];
}

// CIR-BEFORE-LPP:     cir.func {{.*}} @_Z26test_partial_array_cleanupv()
// CIR-BEFORE-LPP:       %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["s", init]
// CIR-BEFORE-LPP:       cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> {
// CIR-BEFORE-LPP:       ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:         cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:       } partial_dtor {
// CIR-BEFORE-LPP:       ^bb0(%[[DTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:         cir.call @_ZN1SD1Ev(%[[DTOR_ARG]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:       }

// CIR:     cir.func {{.*}} @_Z26test_partial_array_cleanupv()
// CIR:       %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["s", init]
// CIR:       %[[CONST4:.*]] = cir.const #cir.int<4> : !u64i
// CIR:       %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR:       %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST4]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR:       %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
// CIR:       cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:       cir.cleanup.scope {
// CIR:         cir.do {
// CIR:           %[[CUR:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:           cir.call @_ZN1SC1Ev(%[[CUR]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR:           %[[CONST1:.*]] = cir.const #cir.int<1> : !u64i
// CIR:           %[[NEXT:.*]] = cir.ptr_stride %[[CUR]], %[[CONST1]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR:           cir.store %[[NEXT]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:           cir.yield
// CIR:         } while {
// CIR:           %[[CUR2:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:           %[[CMP:.*]] = cir.cmp ne %[[CUR2]], %[[END]] : !cir.ptr<!rec_S>
// CIR:           cir.condition(%[[CMP]])
// CIR:         }
// CIR:         cir.yield
// CIR:       } cleanup eh {
// CIR:         %[[CUR3:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:         %[[NE:.*]] = cir.cmp ne %[[CUR3]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:         cir.if %[[NE]] {
// CIR:           cir.do {
// CIR:             %[[EL:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:             %[[NEG1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:             %[[PREV:.*]] = cir.ptr_stride %[[EL]], %[[NEG1]] : (!cir.ptr<!rec_S>, !s64i) -> !cir.ptr<!rec_S>
// CIR:             cir.store %[[PREV]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:             cir.call @_ZN1SD1Ev(%[[PREV]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR:             cir.yield
// CIR:           } while {
// CIR:             %[[EL2:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:             %[[NE2:.*]] = cir.cmp ne %[[EL2]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:             cir.condition(%[[NE2]])
// CIR:           }
// CIR:         }
// CIR:         cir.yield
// CIR:       }

// LLVM:     define dso_local void @_Z26test_partial_array_cleanupv()
// LLVM:       %[[ARRAY:.*]] = alloca [4 x %struct.S]
// LLVM:       %[[BEGIN:.*]] = getelementptr %struct.S, ptr %[[ARRAY]], i32 0
// LLVM:       %[[END:.*]] = getelementptr %struct.S, ptr %[[BEGIN]], i64 4
// LLVM:       %[[ITER:.*]] = alloca ptr
// LLVM:       store ptr %[[BEGIN]], ptr %[[ITER]]
//
//            --- ctor loop condition ---
// LLVM:     [[CLEANUP_SCOPE:.*]]:
// LLVM:       br label %[[CTOR_LOOP_COND:.*]]
//
// LLVM:     [[CTOR_LOOP_COND:]]:
// LLVM:       %[[COND_CUR:.*]] = load ptr, ptr %[[ITER]]
// LLVM:       %[[CTOR_DONE:.*]] = icmp ne ptr %[[COND_CUR]], %[[END]]
// LLVM:       br i1 %[[CTOR_DONE]], label %[[CTOR_BODY:.*]], label %[[CTOR_EXIT:.*]]
//
//            --- ctor loop body ---
// LLVM:     [[CTOR_BODY]]:
// LLVM:       %[[CUR:.*]] = load ptr, ptr %[[ITER]]
// LLVM:       invoke void @_ZN1SC1Ev(ptr{{.*}} %[[CUR]])
// LLVM:         to label %[[CTOR_CONT:.*]] unwind label %[[LPAD:.*]]
//
// LLVM:     [[CTOR_CONT]]:
// LLVM:       %[[NEXT:.*]] = getelementptr %struct.S, ptr %[[CUR]], i64 1
// LLVM:       store ptr %[[NEXT]], ptr %[[ITER]]
// LLVM:       br label %[[CTOR_LOOP_COND]]
//
//            --- landing pad + cleanup guard ---
// LLVM:     [[LPAD]]:
// LLVM:       landingpad { ptr, i32 }
// LLVM:         cleanup
// LLVM:       %[[PAD_CUR:.*]] = load ptr, ptr %[[ITER]]
// LLVM:       %[[GUARD:.*]] = icmp ne ptr %[[PAD_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[GUARD]], label %[[DTOR_ENTRY:.*]], label %[[EH_RESUME:.*]]
//
//            --- partial dtor do-while entry ---
// LLVM:     [[DTOR_ENTRY]]:
// LLVM:       br label %[[DTOR_BODY:.*]]
//
//            --- partial dtor loop condition (back-edge) ---
// LLVM:     [[DTOR_LOOP_COND:.*]]:
// LLVM:       %[[DTOR_CUR:.*]] = load ptr, ptr %[[ITER]]
// LLVM:       %[[DTOR_CONT:.*]] = icmp ne ptr %[[DTOR_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[DTOR_CONT]], label %[[DTOR_BODY]], label %[[DTOR_DONE:.*]]
//
//            --- partial dtor loop body ---
// LLVM:     [[DTOR_BODY]]:
// LLVM:       %[[DCUR:.*]] = load ptr, ptr %[[ITER]]
// LLVM:       %[[PREV:.*]] = getelementptr %struct.S, ptr %[[DCUR]], i64 -1
// LLVM:       store ptr %[[PREV]], ptr %[[ITER]]
// LLVM:       call void @_ZN1SD1Ev(ptr{{.*}} %[[PREV]])
// LLVM:       br label %[[DTOR_LOOP_COND]]
//
// LLVM:     [[DTOR_DONE]]:
// LLVM:       br label %[[EH_RESUME]]
//
// LLVM:     [[EH_RESUME]]:
// LLVM:       resume { ptr, i32 }

// OGCG:     define dso_local void @_Z26test_partial_array_cleanupv()
// OGCG:     [[ENTRY:.*]]:
// OGCG:       %[[ARRAY:.*]] = alloca [4 x %struct.S]
// OGCG:       %[[BEGIN:.*]] = getelementptr inbounds [4 x %struct.S], ptr %[[ARRAY]], i32 0, i32 0
// OGCG:       %[[END:.*]] = getelementptr inbounds %struct.S, ptr %[[BEGIN]], i64 4
//
//            --- ctor loop ---
// OGCG:     [[CTOR_BODY:.*]]:
// OGCG:       %[[CUR:.*]] = phi ptr [ %[[BEGIN]], %[[ENTRY]] ], [ %[[NEXT:.*]], %[[CONT:.*]] ]
// OGCG:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// OGCG:         to label %[[CONT]] unwind label %[[LPAD:.*]]
//
// OGCG:     [[CONT]]:
// OGCG:       %[[NEXT]] = getelementptr inbounds %struct.S, ptr %[[CUR]], i64 1
// OGCG:       %[[DONE:.*]] = icmp eq ptr %[[NEXT]], %[[END]]
// OGCG:       br i1 %[[DONE]], label %[[CTOR_EXIT:.*]], label %[[CTOR_BODY:.*]]
//
//            --- landing pad + cleanup guard ---
// OGCG:     [[LPAD]]:
// OGCG:       landingpad { ptr, i32 }
// OGCG:         cleanup
// OGCG:       %[[ISEMPTY:.*]] = icmp eq ptr %[[BEGIN]], %[[CUR]]
// OGCG:       br i1 %[[ISEMPTY]], label %[[EH_RESUME:.*]], label %[[DTOR_LOOP:.*]]
//
//            --- partial dtor loop ---
// OGCG:     [[DTOR_LOOP]]:
// OGCG:       %[[PAST:.*]] = phi ptr [ %[[CUR]], %[[LPAD]] ], [ %[[PREV:.*]], %[[DTOR_LOOP]] ]
// OGCG:       %[[PREV]] = getelementptr inbounds %struct.S, ptr %[[PAST]], i64 -1
// OGCG:       call void @_ZN1SD1Ev(ptr{{.*}} %[[PREV]])
// OGCG:       %[[DDONE:.*]] = icmp eq ptr %[[PREV]], %[[BEGIN]]
// OGCG:       br i1 %[[DDONE]], label %[[EH_RESUME]], label %[[DTOR_LOOP]]
//
// OGCG:     [[EH_RESUME]]:
// OGCG:       resume { ptr, i32 }

void test_variable_size_partial_array_cleanup(int n) {
    S s[n];
}

// CIR-BEFORE-LPP:     cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
// CIR-BEFORE-LPP:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR-BEFORE-LPP:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP:       cir.stacksave
// CIR-BEFORE-LPP:       cir.cleanup.scope {
// CIR-BEFORE-LPP:         %[[VLA:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[N]] : !u64i, ["s", init]
// CIR-BEFORE-LPP:         cir.array.ctor %[[VLA]], %[[N]] : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:         ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         } partial_dtor {
// CIR-BEFORE-LPP:         ^bb0(%[[DTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SD1Ev(%[[DTOR_ARG]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         }
// CIR-BEFORE-LPP:         cir.cleanup.scope {
// CIR-BEFORE-LPP:           cir.yield
// CIR-BEFORE-LPP:         } cleanup all {
// CIR-BEFORE-LPP:           cir.array.dtor %[[VLA]], %[[N]] : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:           ^bb0(%[[DTOR_ARG2:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:             cir.call @_ZN1SD1Ev(%[[DTOR_ARG2]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:           }
// CIR-BEFORE-LPP:       } cleanup normal {
// CIR-BEFORE-LPP:         cir.stackrestore
// CIR-BEFORE-LPP:       }

// CIR:     cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
// CIR:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR:       %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
// CIR:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR:       %[[STACK:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR:       cir.store {{.*}} %[[STACK]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR:       cir.cleanup.scope {
// CIR:         %[[BEGIN:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[N]] : !u64i, ["s", init]
// CIR:         %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR:         %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CIR:         %[[IS_NONZERO:.*]] = cir.cmp ne %[[N]], %[[ZERO]] : !u64i
// CIR:         cir.if %[[IS_NONZERO]] {
// CIR:           %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
// CIR:           cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:           cir.cleanup.scope {
// CIR:             cir.do {
// CIR:               %[[CUR:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:               cir.call @_ZN1SC1Ev(%[[CUR]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR:               %[[CONST1:.*]] = cir.const #cir.int<1> : !u64i
// CIR:               %[[NEXT:.*]] = cir.ptr_stride %[[CUR]], %[[CONST1]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR:               cir.store %[[NEXT]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:               cir.yield
// CIR:             } while {
// CIR:               %[[CUR2:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:               %[[CMP:.*]] = cir.cmp ne %[[CUR2]], %[[END]] : !cir.ptr<!rec_S>
// CIR:               cir.condition(%[[CMP]])
// CIR:             }
// CIR:             cir.yield
// CIR:           } cleanup eh {
// CIR:             %[[CUR3:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:             %[[NE:.*]] = cir.cmp ne %[[CUR3]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:             cir.if %[[NE]] {
// CIR:               cir.do {
// CIR:                 %[[EL:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:                 %[[NEG1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:                 %[[PREV:.*]] = cir.ptr_stride %[[EL]], %[[NEG1]] : (!cir.ptr<!rec_S>, !s64i) -> !cir.ptr<!rec_S>
// CIR:                 cir.store %[[PREV]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:                 cir.call @_ZN1SD1Ev(%[[PREV]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR:                 cir.yield
// CIR:               } while {
// CIR:                 %[[EL2:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:                 %[[NE2:.*]] = cir.cmp ne %[[EL2]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:                 cir.condition(%[[NE2]])
// CIR:               }
// CIR:             }
// CIR:             cir.yield
// CIR:           }
// CIR:         }
//
//              --- normal dtor ---
// CIR:         } cleanup all {
// CIR:           %[[LAST:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR:           %[[DTOR_NE:.*]] = cir.cmp ne %[[LAST]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:           cir.if %[[DTOR_NE]] {
// CIR:             %[[DTOR_ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
// CIR:             cir.store %[[LAST]], %[[DTOR_ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:             cir.do {
// CIR:               %[[DTOR_CUR:.*]] = cir.load %[[DTOR_ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:               %[[DTOR_NEG1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:               %[[DTOR_PREV:.*]] = cir.ptr_stride %[[DTOR_CUR]], %[[DTOR_NEG1]] : (!cir.ptr<!rec_S>, !s64i) -> !cir.ptr<!rec_S>
// CIR:               cir.store %[[DTOR_PREV]], %[[DTOR_ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:               cir.call @_ZN1SD1Ev(%[[DTOR_PREV]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR:               cir.yield
// CIR:             } while {
// CIR:               %[[DTOR_CUR2:.*]] = cir.load %[[DTOR_ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:               %[[DTOR_NE2:.*]] = cir.cmp ne %[[DTOR_CUR2]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:               cir.condition(%[[DTOR_NE2]])
// CIR:             }
// CIR:           }
// CIR:           cir.yield
// CIR:         }
// CIR:         cir.yield
// CIR:       } cleanup normal {
// CIR:         cir.stackrestore {{.*}} : !cir.ptr<!u8i>
// CIR:         cir.yield
// CIR:       }

// LLVM:     define dso_local void @_Z40test_variable_size_partial_array_cleanupi
// LLVM:       %[[N_I32:.*]] = load i32, ptr %{{.*}}
// LLVM:       %[[N:.*]] = sext i32 %[[N_I32]] to i64
// LLVM:       call ptr @llvm.stacksave.p0()
//
//            --- VLA alloca + zero check ---
// LLVM:       %[[BEGIN:.*]] = alloca %struct.S, i64 %[[N]]
// LLVM:       %[[END:.*]] = getelementptr %struct.S, ptr %[[BEGIN]], i64 %[[N]]
// LLVM:       %[[IS_NONZERO:.*]] = icmp ne i64 %[[N]], 0
// LLVM:       br i1 %[[IS_NONZERO]], label %[[CTOR_SETUP:.*]], label %[[AFTER_CTOR:.*]]
//
//            --- ctor init ---
// LLVM:     [[CTOR_SETUP]]:
// LLVM:       store ptr %[[BEGIN]], ptr %[[CTOR_ITER:.*]]
// LLVM:       br label %[[CTOR_ENTRY:.*]]
//
// LLVM:     [[CTOR_ENTRY]]:
// LLVM:       br label %[[CTOR_BODY:.*]]
//
//            --- ctor loop condition (back-edge) ---
// LLVM:     [[CTOR_LOOP_COND:.*]]:
// LLVM:       %[[COND_CUR:.*]] = load ptr, ptr %[[CTOR_ITER]]
// LLVM:       %[[CTOR_DONE:.*]] = icmp ne ptr %[[COND_CUR]], %[[END]]
// LLVM:       br i1 %[[CTOR_DONE]], label %[[CTOR_BODY]], label %[[CTOR_EXIT:.*]]
//
//            --- ctor loop body ---
// LLVM:     [[CTOR_BODY]]:
// LLVM:       %[[CUR:.*]] = load ptr, ptr %[[CTOR_ITER]]
// LLVM:       invoke void @_ZN1SC1Ev(ptr{{.*}} %[[CUR]])
// LLVM:         to label %[[CTOR_CONT:.*]] unwind label %[[LPAD:.*]]
//
// LLVM:     [[CTOR_CONT]]:
// LLVM:       %[[NEXT:.*]] = getelementptr %struct.S, ptr %[[CUR]], i64 1
// LLVM:       store ptr %[[NEXT]], ptr %[[CTOR_ITER]]
// LLVM:       br label %[[CTOR_LOOP_COND]]
//
// LLVM:     [[CTOR_EXIT]]:
// LLVM:       br label %[[CTOR_JOIN:.*]]
//
//            --- landing pad + cleanup guard ---
// LLVM:     [[LPAD]]:
// LLVM:       landingpad { ptr, i32 }
// LLVM:         cleanup
// LLVM:       %[[PAD_CUR:.*]] = load ptr, ptr %[[CTOR_ITER]]
// LLVM:       %[[GUARD:.*]] = icmp ne ptr %[[PAD_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[GUARD]], label %[[PDTOR_ENTRY:.*]], label %[[EH_RESUME:.*]]
//
//            --- partial dtor do-while entry ---
// LLVM:     [[PDTOR_ENTRY]]:
// LLVM:       br label %[[PDTOR_BODY:.*]]
//
//            --- partial dtor loop condition (back-edge) ---
// LLVM:     [[PDTOR_LOOP_COND:.*]]:
// LLVM:       %[[PDTOR_CUR:.*]] = load ptr, ptr %[[CTOR_ITER]]
// LLVM:       %[[PDTOR_CONT:.*]] = icmp ne ptr %[[PDTOR_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[PDTOR_CONT]], label %[[PDTOR_BODY]], label %[[PDTOR_DONE:.*]]
//
//            --- partial dtor loop body ---
// LLVM:     [[PDTOR_BODY]]:
// LLVM:       %[[PDCUR:.*]] = load ptr, ptr %[[CTOR_ITER]]
// LLVM:       %[[PPREV:.*]] = getelementptr %struct.S, ptr %[[PDCUR]], i64 -1
// LLVM:       store ptr %[[PPREV]], ptr %[[CTOR_ITER]]
// LLVM:       call void @_ZN1SD1Ev(ptr{{.*}} %[[PPREV]])
// LLVM:       br label %[[PDTOR_LOOP_COND]]
//
// LLVM:     [[PDTOR_DONE]]:
// LLVM:       br label %[[EH_RESUME]]
//
// LLVM:     [[EH_RESUME]]:
// LLVM:       resume { ptr, i32 }
//
//            --- ctor done join ---
// LLVM:     [[CTOR_JOIN]]:
// LLVM:       br label %[[AFTER_CTOR]]
//
//            --- normal dtor setup ---
// LLVM:     [[AFTER_CTOR]]:
// LLVM:       %[[LAST:.*]] = getelementptr %struct.S, ptr %[[BEGIN]], i64 %[[N]]
// LLVM:       %[[DTOR_NE:.*]] = icmp ne ptr %[[LAST]], %[[BEGIN]]
// LLVM:       br i1 %[[DTOR_NE]], label %[[NDTOR_ENTRY:.*]], label %[[NDTOR_DONE:.*]]
//
// LLVM:     [[NDTOR_ENTRY]]:
// LLVM:       store ptr %[[LAST]], ptr %[[DTOR_ITER:.*]]
// LLVM:       br label %[[NDTOR_BODY:.*]]
//
//            --- normal dtor loop condition (back-edge) ---
// LLVM:     [[NDTOR_LOOP_COND:.*]]:
// LLVM:       %[[NDCUR_CHECK:.*]] = load ptr, ptr %[[DTOR_ITER]]
// LLVM:       %[[NDTOR_CONT:.*]] = icmp ne ptr %[[NDCUR_CHECK]], %[[BEGIN]]
// LLVM:       br i1 %[[NDTOR_CONT]], label %[[NDTOR_BODY]], label %[[NDTOR_EXIT:.*]]
//
//            --- normal dtor loop body ---
// LLVM:     [[NDTOR_BODY]]:
// LLVM:       %[[NDCUR:.*]] = load ptr, ptr %[[DTOR_ITER]]
// LLVM:       %[[NDPREV:.*]] = getelementptr %struct.S, ptr %[[NDCUR]], i64 -1
// LLVM:       store ptr %[[NDPREV]], ptr %[[DTOR_ITER]]
// LLVM:       call void @_ZN1SD1Ev(ptr{{.*}} %[[NDPREV]])
// LLVM:       br label %[[NDTOR_LOOP_COND]]
//
// LLVM:     [[NDTOR_EXIT]]:
// LLVM:       br label %[[NDTOR_DONE]]
//
// LLVM:     [[NDTOR_DONE]]:
// LLVM:       call void @llvm.stackrestore.p0
// LLVM:       ret void

// OGCG:     define dso_local void @_Z40test_variable_size_partial_array_cleanupi
// OGCG:     [[ENTRY:.*]]:
// OGCG:       %[[N:.*]] = zext i32 %{{.*}} to i64
// OGCG:       %[[VLA:.*]] = alloca %struct.S, i64 %[[N]]
// OGCG:       %[[ISEMPTY:.*]] = icmp eq i64 %[[N]], 0
// OGCG:       br i1 %[[ISEMPTY]], label %[[CTOR_CONT:.*]], label %[[CTOR_LOOP_ENTRY:.*]]
//
//            --- ctor loop ---
// OGCG:     [[CTOR_LOOP_ENTRY]]:
// OGCG:       %[[CTOR_END:.*]] = getelementptr inbounds %struct.S, ptr %[[VLA]], i64 %[[N]]
// OGCG:       br label %[[CTOR_LOOP:.*]]
//
// OGCG:     [[CTOR_LOOP]]:
// OGCG:       %[[CUR:.*]] = phi ptr [ %[[VLA]], %[[CTOR_LOOP_ENTRY]] ], [ %[[NEXT:.*]], %[[INVOKE_CONT:.*]] ]
// OGCG:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// OGCG:         to label %[[INVOKE_CONT]] unwind label %[[LPAD:.*]]
//
// OGCG:     [[INVOKE_CONT]]:
// OGCG:       %[[NEXT]] = getelementptr inbounds %struct.S, ptr %[[CUR]], i64 1
// OGCG:       %[[DONE:.*]] = icmp eq ptr %[[NEXT]], %[[CTOR_END]]
// OGCG:       br i1 %[[DONE]], label %[[CTOR_CONT]], label %[[CTOR_LOOP]]
//
//            --- normal dtor ---
// OGCG:     [[CTOR_CONT]]:
// OGCG:       %[[DTOR_END:.*]] = getelementptr inbounds %struct.S, ptr %[[VLA]], i64 %[[N]]
// OGCG:       %[[DTOR_ISEMPTY:.*]] = icmp eq ptr %[[VLA]], %[[DTOR_END]]
// OGCG:       br i1 %[[DTOR_ISEMPTY]], label %[[DTOR_DONE:.*]], label %[[DTOR_LOOP:.*]]
//
// OGCG:     [[DTOR_LOOP]]:
// OGCG:       %[[PAST:.*]] = phi ptr [ %[[DTOR_END]], %[[CTOR_CONT]] ], [ %[[PREV:.*]], %[[DTOR_LOOP]] ]
// OGCG:       %[[PREV]] = getelementptr inbounds %struct.S, ptr %[[PAST]], i64 -1
// OGCG:       call void @_ZN1SD1Ev(ptr{{.*}} %[[PREV]])
// OGCG:       %[[DDONE:.*]] = icmp eq ptr %[[PREV]], %[[VLA]]
// OGCG:       br i1 %[[DDONE]], label %[[DTOR_DONE]], label %[[DTOR_LOOP]]
//
// OGCG:     [[DTOR_DONE]]:
// OGCG:       call void @llvm.stackrestore.p0(ptr %{{.*}})
// OGCG:       ret void
//
//            --- landing pad + cleanup guard ---
// OGCG:     [[LPAD]]:
// OGCG:       landingpad { ptr, i32 }
// OGCG:         cleanup
// OGCG:       %[[PISEMPTY:.*]] = icmp eq ptr %[[VLA]], %[[CUR]]
// OGCG:       br i1 %[[PISEMPTY]], label %[[PDTOR_DONE:.*]], label %[[PDTOR_LOOP:.*]]
//
//            --- partial dtor loop ---
// OGCG:     [[PDTOR_LOOP]]:
// OGCG:       %[[PPAST:.*]] = phi ptr [ %[[CUR]], %[[LPAD]] ], [ %[[PPREV:.*]], %[[PDTOR_LOOP]] ]
// OGCG:       %[[PPREV]] = getelementptr inbounds %struct.S, ptr %[[PPAST]], i64 -1
// OGCG:       call void @_ZN1SD1Ev(ptr{{.*}} %[[PPREV]])
// OGCG:       %[[PDDONE:.*]] = icmp eq ptr %[[PPREV]], %[[VLA]]
// OGCG:       br i1 %[[PDDONE]], label %[[PDTOR_DONE]], label %[[PDTOR_LOOP]]
//
// OGCG:     [[PDTOR_DONE]]:
// OGCG:       br label %[[EH_RESUME:.*]]
//
// OGCG:     [[EH_RESUME]]:
// OGCG:       resume { ptr, i32 }

void test_multi_dim_vla(int n, int m) {
    S s[n][m];
}

// CIR-BEFORE-LPP:     cir.func {{.*}} @_Z18test_multi_dim_vlaii
// CIR-BEFORE-LPP:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR-BEFORE-LPP:       %[[M_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["m", init]
// CIR-BEFORE-LPP:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP:       %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP:       %[[M:.*]] = cir.cast integral %[[M_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP:       cir.stacksave
// CIR-BEFORE-LPP:       cir.cleanup.scope {
// CIR-BEFORE-LPP:         %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
// CIR-BEFORE-LPP:         %[[VLA:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[NM]] : !u64i, ["s", init]
// CIR-BEFORE-LPP:         cir.array.ctor %[[VLA]], {{.*}} : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:         ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         } partial_dtor {
// CIR-BEFORE-LPP:         ^bb0(%[[DTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SD1Ev(%[[DTOR_ARG]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         }
// CIR-BEFORE-LPP:         cir.cleanup.scope {
// CIR-BEFORE-LPP:           cir.yield
// CIR-BEFORE-LPP:         } cleanup all {
// CIR-BEFORE-LPP:           cir.array.dtor %[[VLA]], {{.*}} : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:           ^bb0(%[[DTOR_ARG2:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:             cir.call @_ZN1SD1Ev(%[[DTOR_ARG2]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:           }
// CIR-BEFORE-LPP:       } cleanup normal {
// CIR-BEFORE-LPP:         cir.stackrestore
// CIR-BEFORE-LPP:       }

// CIR:     cir.func {{.*}} @_Z18test_multi_dim_vlaii
// CIR:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR:       %[[M_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["m", init]
// CIR:       %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
// CIR:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR:       %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR:       %[[M:.*]] = cir.cast integral %[[M_VAL]] : !s32i -> !u64i
// CIR:       cir.cleanup.scope {
// CIR:         %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
// CIR:         %[[BEGIN:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[NM]] : !u64i, ["s", init]
// CIR:         cir.call @_ZN1SC1Ev
// CIR:         } cleanup eh {
// CIR:           cir.call @_ZN1SD1Ev
// CIR:         } cleanup all {
// CIR:           %[[NM3:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
// CIR:           cir.call @_ZN1SD1Ev
// CIR:       } cleanup normal {
// CIR:         cir.stackrestore {{.*}} : !cir.ptr<!u8i>
// CIR:       }

// LLVM:     define dso_local void @_Z18test_multi_dim_vlaii
// LLVM:       %[[N_I32:.*]] = load i32, ptr %{{.*}}
// LLVM:       %[[N:.*]] = sext i32 %[[N_I32]] to i64
// LLVM:       %[[M_I32:.*]] = load i32, ptr %{{.*}}
// LLVM:       %[[M:.*]] = sext i32 %[[M_I32]] to i64
// LLVM:       call ptr @llvm.stacksave.p0()
//
//            --- VLA alloca with n*m ---
// LLVM:       %[[NM:.*]] = mul nuw i64 %[[N]], %[[M]]
// LLVM:       %[[BEGIN:.*]] = alloca %struct.S, i64 %[[NM]]
//
//            --- ctor loop ---
// LLVM:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// LLVM:         to label %{{.*}} unwind label %[[LPAD:.*]]
//
//            --- landing pad + partial dtor ---
// LLVM:     [[LPAD]]:
// LLVM:       landingpad { ptr, i32 }
// LLVM:         cleanup
// LLVM:       call void @_ZN1SD1Ev
// LLVM:       resume { ptr, i32 }
//
//            --- normal dtor ---
// LLVM:       %[[NM2:.*]] = mul nuw i64 %[[N]], %[[M]]
// LLVM:       %[[LAST:.*]] = getelementptr %struct.S, ptr %[[BEGIN]], i64 %[[NM2]]
// LLVM:       %[[DTOR_NE:.*]] = icmp ne ptr %[[LAST]], %[[BEGIN]]
// LLVM:       call void @_ZN1SD1Ev
// LLVM:       call void @llvm.stackrestore.p0
// LLVM:       ret void

// OGCG:     define dso_local void @_Z18test_multi_dim_vlaii
// OGCG:     [[ENTRY:.*]]:
// OGCG:       %[[N:.*]] = zext i32 %{{.*}} to i64
// OGCG:       %[[M:.*]] = zext i32 %{{.*}} to i64
// OGCG:       %[[NM:.*]] = mul nuw i64 %[[N]], %[[M]]
// OGCG:       %[[VLA:.*]] = alloca %struct.S, i64 %[[NM]]
// OGCG:       %[[ISEMPTY:.*]] = icmp eq i64 %{{.*}}, 0
// OGCG:       br i1 %[[ISEMPTY]], label %[[CTOR_CONT:.*]], label %[[CTOR_LOOP_ENTRY:.*]]
//
//            --- ctor loop ---
// OGCG:     [[CTOR_LOOP_ENTRY]]:
// OGCG:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// OGCG:         to label %{{.*}} unwind label %[[LPAD:.*]]
//
//            --- normal dtor ---
// OGCG:     [[CTOR_CONT]]:
// OGCG:       %[[NM2:.*]] = mul nuw i64 %[[N]], %[[M]]
// OGCG:       call void @_ZN1SD1Ev
//
// OGCG:       call void @llvm.stackrestore.p0(ptr %{{.*}})
// OGCG:       ret void
//
//            --- landing pad + partial dtor ---
// OGCG:     [[LPAD]]:
// OGCG:       landingpad { ptr, i32 }
// OGCG:         cleanup
// OGCG:       call void @_ZN1SD1Ev
//
// OGCG:       resume { ptr, i32 }

void test_vla_of_constant_array(int n) {
    S s[n][4];
}

// CIR-BEFORE-LPP:     cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
// CIR-BEFORE-LPP:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR-BEFORE-LPP:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP:       cir.stacksave
// CIR-BEFORE-LPP:       cir.cleanup.scope {
// CIR-BEFORE-LPP:         %[[VLA:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, %[[N]] : !u64i, ["s", init]
// CIR-BEFORE-LPP:         %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR-BEFORE-LPP:         %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR-BEFORE-LPP:         %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR-BEFORE-LPP:         cir.array.ctor %[[ELEM_PTR]], %[[TOTAL]] : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:         ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         } partial_dtor {
// CIR-BEFORE-LPP:         ^bb0(%[[DTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:           cir.call @_ZN1SD1Ev(%[[DTOR_ARG]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:         }
// CIR-BEFORE-LPP:         cir.cleanup.scope {
// CIR-BEFORE-LPP:           cir.yield
// CIR-BEFORE-LPP:         } cleanup all {
// CIR-BEFORE-LPP:           %{{.*}} = cir.const #cir.int<4> : !u64i
// CIR-BEFORE-LPP:           %{{.*}} = cir.mul nuw %[[N]], %{{.*}} : !u64i
// CIR-BEFORE-LPP:           %{{.*}} = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR-BEFORE-LPP:           cir.array.dtor {{.*}} : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP:           ^bb0(%[[DTOR_ARG2:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP:             cir.call @_ZN1SD1Ev(%[[DTOR_ARG2]]){{.*}} : (!cir.ptr<!rec_S>{{.*}}) -> ()
// CIR-BEFORE-LPP:           }
// CIR-BEFORE-LPP:       } cleanup normal {
// CIR-BEFORE-LPP:         cir.stackrestore
// CIR-BEFORE-LPP:       }

// CIR:     cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
// CIR:       %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR:       %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR:       %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR:       cir.cleanup.scope {
// CIR:         %[[VLA:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, %[[N]] : !u64i, ["s", init]
// CIR:         %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR:         %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR:         %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR:         cir.call @_ZN1SC1Ev
// CIR:         } cleanup eh {
// CIR:           cir.call @_ZN1SD1Ev
// CIR:         } cleanup all {
// CIR:           %{{.*}} = cir.const #cir.int<4> : !u64i
// CIR:           %{{.*}} = cir.mul nuw %[[N]], %{{.*}} : !u64i
// CIR:           %{{.*}} = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR:           cir.call @_ZN1SD1Ev
// CIR:       } cleanup normal {
// CIR:         cir.stackrestore {{.*}} : !cir.ptr<!u8i>
// CIR:       }

// LLVM:     define dso_local void @_Z26test_vla_of_constant_arrayi
// LLVM:       %[[N_I32:.*]] = load i32, ptr %{{.*}}
// LLVM:       %[[N:.*]] = sext i32 %[[N_I32]] to i64
// LLVM:       call ptr @llvm.stacksave.p0()
//
//            --- VLA alloca with [4 x %struct.S] ---
// LLVM:       %[[BEGIN:.*]] = alloca [4 x %struct.S], i64 %[[N]]
// LLVM:       %[[TOTAL:.*]] = mul nuw i64 %[[N]], 4
//
//            --- ctor loop ---
// LLVM:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// LLVM:         to label %{{.*}} unwind label %[[LPAD:.*]]
//
//            --- landing pad + partial dtor ---
// LLVM:     [[LPAD]]:
// LLVM:       landingpad { ptr, i32 }
// LLVM:         cleanup
// LLVM:       call void @_ZN1SD1Ev
// LLVM:       resume { ptr, i32 }
//
//            --- normal dtor ---
// LLVM:       %[[TOTAL2:.*]] = mul nuw i64 %[[N]], 4
// LLVM:       call void @_ZN1SD1Ev
// LLVM:       call void @llvm.stackrestore.p0
// LLVM:       ret void

// OGCG:     define dso_local void @_Z26test_vla_of_constant_arrayi
// OGCG:     [[ENTRY:.*]]:
// OGCG:       %[[N:.*]] = zext i32 %{{.*}} to i64
// OGCG:       %[[VLA:.*]] = alloca [4 x %struct.S], i64 %[[N]]
// OGCG:       %[[ARRAY_BEGIN:.*]] = getelementptr inbounds [4 x %struct.S], ptr %[[VLA]], i32 0, i32 0
// OGCG:       %[[TOTAL:.*]] = mul nuw i64 %[[N]], 4
// OGCG:       %[[ISEMPTY:.*]] = icmp eq i64 %[[TOTAL]], 0
// OGCG:       br i1 %[[ISEMPTY]], label %[[CTOR_CONT:.*]], label %[[CTOR_LOOP_ENTRY:.*]]
//
//            --- ctor loop ---
// OGCG:     [[CTOR_LOOP_ENTRY]]:
// OGCG:       invoke void @_ZN1SC1Ev(ptr{{.*}})
// OGCG:         to label %{{.*}} unwind label %[[LPAD:.*]]
//
//            --- normal dtor ---
// OGCG:     [[CTOR_CONT]]:
// OGCG:       %[[TOTAL2:.*]] = mul nuw i64 %[[N]], 4
// OGCG:       call void @_ZN1SD1Ev
//
// OGCG:       call void @llvm.stackrestore.p0(ptr %{{.*}})
// OGCG:       ret void
//
//            --- landing pad + partial dtor ---
// OGCG:     [[LPAD]]:
// OGCG:       landingpad { ptr, i32 }
// OGCG:         cleanup
// OGCG:       call void @_ZN1SD1Ev
//
// OGCG:       resume { ptr, i32 }

void test_init_list_partial_array_cleanup() {
    S arr[4] = { S(), S() };
}

// CIR-LABEL:     cir.func {{.*}} @_Z36test_init_list_partial_array_cleanupv()
// CIR:       %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["arr", init]
// CIR:       %[[END_OF_INIT:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["arrayinit.endOfInit"]
// CIR:       %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR:       cir.store {{.*}} %[[BEGIN]], %[[END_OF_INIT]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR:       cir.cleanup.scope {
//              --- first explicit init ---
// CIR:         cir.call @_ZN1SC1Ev(%[[BEGIN]])
//              --- advance + update endOfInit for second element ---
// CIR:         %[[SECOND:.*]] = cir.ptr_stride %[[BEGIN]], %{{.*}}
// CIR:         cir.store {{.*}} %[[SECOND]], %[[END_OF_INIT]]
//              --- second explicit init ---
// CIR:         cir.call @_ZN1SC1Ev(%[[SECOND]])
//              --- advance + update endOfInit for filler start ---
// CIR:         %[[FILLER_START:.*]] = cir.ptr_stride %[[SECOND]], %{{.*}}
// CIR:         cir.store {{.*}} %[[FILLER_START]], %[[END_OF_INIT]]
//              --- do-while filler loop ---
// CIR:         cir.do {
// CIR:           %[[CUR:.*]] = cir.load {{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:           cir.call @_ZN1SC1Ev(%[[CUR]])
// CIR:           %[[NEXT:.*]] = cir.ptr_stride %[[CUR]], %{{.*}}
// CIR:           cir.store {{.*}} %[[NEXT]], %[[END_OF_INIT]]
// CIR:           cir.yield
// CIR:         } while {
// CIR:           cir.condition(%{{.*}})
// CIR:         }
// CIR:         cir.yield
//              --- EH cleanup: partial destruction ---
// CIR:       } cleanup eh {
// CIR:         %[[END_VAL:.*]] = cir.load {{.*}} %[[END_OF_INIT]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:         %[[NE:.*]] = cir.cmp ne %[[END_VAL]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:         cir.if %[[NE]] {
// CIR:           cir.do {
// CIR:             %[[EL:.*]] = cir.load {{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:             %[[NEG1:.*]] = cir.const #cir.int<-1> : !s64i
// CIR:             %[[PREV:.*]] = cir.ptr_stride %[[EL]], %[[NEG1]] : (!cir.ptr<!rec_S>, !s64i) -> !cir.ptr<!rec_S>
// CIR:             cir.call @_ZN1SD1Ev(%[[PREV]])
// CIR:             cir.yield
// CIR:           } while {
// CIR:             %[[EL2:.*]] = cir.load {{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR:             %[[NE2:.*]] = cir.cmp ne %[[EL2]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR:             cir.condition(%[[NE2]])
// CIR:           }
// CIR:         }
// CIR:         cir.yield
// CIR:       }

// LLVM-LABEL:  define dso_local void @_Z36test_init_list_partial_array_cleanupv()
// LLVM:       %[[ARRAY:.*]] = alloca [4 x %struct.S]
// LLVM:       %[[BEGIN:.*]] = getelementptr %struct.S, ptr %[[ARRAY]], i32 0
// LLVM:       store ptr %[[BEGIN]], ptr %[[END_OF_INIT:.*]]
//
//            --- first ctor ---
// LLVM:       invoke void @_ZN1SC1Ev(ptr {{.*}} %[[BEGIN]])
// LLVM:         to label %[[CONT1:.*]] unwind label %[[LPAD:.*]]
//
//            --- second ctor ---
// LLVM:     [[CONT1]]:
// LLVM:       %[[SECOND:.*]] = getelementptr %struct.S, ptr %[[BEGIN]], i64 1
// LLVM:       store ptr %[[SECOND]], ptr %[[END_OF_INIT]]
// LLVM:       invoke void @_ZN1SC1Ev(ptr {{.*}} %[[SECOND]])
// LLVM:         to label %{{.*}} unwind label %[[LPAD]]
//
//            --- filler loop with invoke ---
// LLVM:       invoke void @_ZN1SC1Ev(ptr {{.*}})
// LLVM:         to label %[[FILLER_CONT:.*]] unwind label %[[LPAD]]
//
// LLVM:     [[FILLER_CONT]]:
// LLVM:       %[[FNEXT:.*]] = getelementptr %struct.S, ptr %{{.*}}, i64 1
// LLVM:       store ptr %[[FNEXT]], ptr %[[END_OF_INIT]]
//
//            --- landing pad + cleanup guard ---
// LLVM:     [[LPAD]]:
// LLVM:       landingpad { ptr, i32 }
// LLVM:         cleanup
// LLVM:       %[[PAD_CUR:.*]] = load ptr, ptr %[[END_OF_INIT]]
// LLVM:       %[[GUARD:.*]] = icmp ne ptr %[[PAD_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[GUARD]], label %[[DTOR_ENTRY:.*]], label %[[EH_RESUME:.*]]
//
//            --- partial dtor do-while loop ---
// LLVM:     [[DTOR_ENTRY]]:
// LLVM:       store ptr %[[PAD_CUR]], ptr %[[DTOR_ITER:.*]]
// LLVM:       br label %[[DTOR_BODY:.*]]
//
// LLVM:     [[DTOR_LOOP_COND:.*]]:
// LLVM:       %[[DTOR_CUR:.*]] = load ptr, ptr %[[DTOR_ITER]]
// LLVM:       %[[DTOR_CONT:.*]] = icmp ne ptr %[[DTOR_CUR]], %[[BEGIN]]
// LLVM:       br i1 %[[DTOR_CONT]], label %[[DTOR_BODY]], label %[[DTOR_DONE:.*]]
//
// LLVM:     [[DTOR_BODY]]:
// LLVM:       %[[DCUR:.*]] = load ptr, ptr %[[DTOR_ITER]]
// LLVM:       %[[PREV:.*]] = getelementptr %struct.S, ptr %[[DCUR]], i64 -1
// LLVM:       store ptr %[[PREV]], ptr %[[DTOR_ITER]]
// LLVM:       call void @_ZN1SD1Ev(ptr {{.*}} %[[PREV]])
// LLVM:       br label %[[DTOR_LOOP_COND]]
//
// LLVM:     [[DTOR_DONE]]:
// LLVM:       br label %[[EH_RESUME]]
//
// LLVM:     [[EH_RESUME]]:
// LLVM:       resume { ptr, i32 }

// OGCG-LABEL: define dso_local void @_Z36test_init_list_partial_array_cleanupv()
// OGCG:       %[[ARR:.*]] = alloca [4 x %struct.S]
// OGCG:       %[[END_OF_INIT:.*]] = alloca ptr
// OGCG:       store ptr %[[ARR]], ptr %[[END_OF_INIT]]
//
//            --- first explicit ctor ---
// OGCG:       invoke void @_ZN1SC1Ev(ptr {{.*}} %[[ARR]])
// OGCG:         to label %[[CONT1:.*]] unwind label %[[LPAD:.*]]
//
//            --- second explicit ctor ---
// OGCG:     [[CONT1]]:
// OGCG:       %[[EL1:.*]] = getelementptr inbounds %struct.S, ptr %[[ARR]], i64 1
// OGCG:       store ptr %[[EL1]], ptr %[[END_OF_INIT]]
// OGCG:       invoke void @_ZN1SC1Ev(ptr {{.*}} %[[EL1]])
// OGCG:         to label %[[CONT2:.*]] unwind label %[[LPAD]]
//
//            --- filler loop setup ---
// OGCG:     [[CONT2]]:
// OGCG:       %[[FILLER_START:.*]] = getelementptr inbounds %struct.S, ptr %[[ARR]], i64 2
// OGCG:       store ptr %[[FILLER_START]], ptr %[[END_OF_INIT]]
// OGCG:       %[[FILLER_END:.*]] = getelementptr inbounds %struct.S, ptr %[[ARR]], i64 4
// OGCG:       br label %[[FILLER_BODY:.*]]
//
//            --- filler loop body ---
// OGCG:     [[FILLER_BODY]]:
// OGCG:       %[[FILLER_CUR:.*]] = phi ptr [ %[[FILLER_START]], %[[CONT2]] ], [ %[[FILLER_NEXT:.*]], %[[FILLER_CONT:.*]] ]
// OGCG:       invoke void @_ZN1SC1Ev(ptr {{.*}} %[[FILLER_CUR]])
// OGCG:         to label %[[FILLER_CONT]] unwind label %[[LPAD]]
//
// OGCG:     [[FILLER_CONT]]:
// OGCG:       %[[FILLER_NEXT]] = getelementptr inbounds %struct.S, ptr %[[FILLER_CUR]], i64 1
// OGCG:       store ptr %[[FILLER_NEXT]], ptr %[[END_OF_INIT]]
// OGCG:       %[[FILLER_DONE:.*]] = icmp eq ptr %[[FILLER_NEXT]], %[[FILLER_END]]
// OGCG:       br i1 %[[FILLER_DONE]], label %{{.*}}, label %[[FILLER_BODY]]
//
//            --- landing pad + partial destruction ---
// OGCG:     [[LPAD]]:
// OGCG:       landingpad { ptr, i32 }
// OGCG:         cleanup
// OGCG:       %[[PAD_END:.*]] = load ptr, ptr %[[END_OF_INIT]]
// OGCG:       %[[ISEMPTY:.*]] = icmp eq ptr %[[ARR]], %[[PAD_END]]
// OGCG:       br i1 %[[ISEMPTY]], label %[[DTOR_DONE:.*]], label %[[DTOR_LOOP:.*]]
//
// OGCG:     [[DTOR_LOOP]]:
// OGCG:       %[[DTOR_PAST:.*]] = phi ptr [ %[[PAD_END]], %[[LPAD]] ], [ %[[DTOR_PREV:.*]], %[[DTOR_LOOP]] ]
// OGCG:       %[[DTOR_PREV]] = getelementptr inbounds %struct.S, ptr %[[DTOR_PAST]], i64 -1
// OGCG:       call void @_ZN1SD1Ev(ptr {{.*}} %[[DTOR_PREV]])
// OGCG:       %[[DTOR_CONT:.*]] = icmp eq ptr %[[DTOR_PREV]], %[[ARR]]
// OGCG:       br i1 %[[DTOR_CONT]], label %[[DTOR_DONE]], label %[[DTOR_LOOP]]
//
// OGCG:     [[DTOR_DONE]]:
// OGCG:       br label %[[EH_RESUME:.*]]
//
// OGCG:     [[EH_RESUME]]:
// OGCG:       resume { ptr, i32 }