| // RUN: %clang_cc1 -no-enable-noundef-analysis %s -triple=x86_64-linux-gnu -fclangir -emit-cir -std=c++98 -fcxx-exceptions -fexceptions -o %t.cir | |
| // RUN: FileCheck -check-prefixes=CIR --input-file=%t.cir %s | |
| // RUN: %clang_cc1 -no-enable-noundef-analysis %s -triple=x86_64-linux-gnu -fclangir -emit-llvm -std=c++98 -fcxx-exceptions -fexceptions -o %t-cir.ll | |
| // RUN: FileCheck -check-prefixes=LLVM --input-file=%t-cir.ll %s | |
| // RUN: %clang_cc1 -no-enable-noundef-analysis %s -triple=x86_64-linux-gnu -emit-llvm -std=c++98 -fcxx-exceptions -fexceptions -o %t.ll | |
| // RUN: FileCheck -check-prefixes=OGCG --input-file=%t.ll %s | |
| struct A { A(int); ~A(); void *p; }; | |
| A *a() { | |
| return new A(5); | |
| } | |
| // CIR: cir.func {{.*}} @_Z1av() -> !cir.ptr<!rec_A>{{.*}} { | |
| // CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i | |
| // CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[PTR_A:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_A> | |
| // CIR: cir.store{{.*}} %[[PTR_A]], %[[NEW_RESULT]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s32i | |
| // CIR: cir.call @_ZN1AC1Ei(%[[PTR_A]], %[[FIVE]]) | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: cir.call @_ZdlPv(%[[PTR]]) nothrow {builtin} : (!cir.ptr<!void>) -> () | |
| // CIR: cir.yield | |
| // CIR: } | |
| // LLVM: define {{.*}} ptr @_Z1av() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // LLVM: %[[RETVAL:.*]] = alloca ptr | |
| // LLVM: %[[NEW_RESULT:.*]] = alloca ptr | |
| // LLVM: %[[PTR:.*]] = call noalias nonnull ptr @_Znwm(i64 8) #[[ATTR_BUILTIN_NEW:.*]] | |
| // LLVM: br label %[[EH_SCOPE:.*]] | |
| // LLVM: [[EH_SCOPE]]: | |
| // LLVM: store ptr %[[PTR]], ptr %[[NEW_RESULT]] | |
| // LLVM: invoke void @_ZN1AC1Ei(ptr {{.*}} %[[PTR]], i32 5) | |
| // LLVM: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // LLVM: [[INVOKE_CONT]]: | |
| // LLVM: br label %[[EH_SCOPE_END:.*]] | |
| // LLVM: [[UNWIND]]: | |
| // LLVM: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // LLVM: cleanup | |
| // LLVM: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // LLVM: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // LLVM: br label %[[EH_CLEANUP:.*]] | |
| // LLVM: [[EH_CLEANUP]]: | |
| // LLVM: %[[EXN_PTR_PHI:.*]] = phi ptr [ %[[EXN_PTR]], %[[UNWIND]] ] | |
| // LLVM: %[[TYPEID_PHI:.*]] = phi i32 [ %[[TYPEID]], %[[UNWIND]] ] | |
| // LLVM: call void @_ZdlPv(ptr %[[PTR]]) #[[ATTR_BUILTIN_DEL:.*]] | |
| // LLVM: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR_PHI]], 0 | |
| // LLVM: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[TYPEID_PHI]], 1 | |
| // LLVM: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| // LLVM: [[EH_SCOPE_END]]: | |
| // LLVM: %[[LOAD:.*]] = load ptr, ptr %[[NEW_RESULT]] | |
| // LLVM: store ptr %[[LOAD]], ptr %[[RETVAL]] | |
| // LLVM: %[[RET:.*]] = load ptr, ptr %[[RETVAL]] | |
| // LLVM: ret ptr %[[RET]] | |
| // OGCG: define {{.*}} ptr @_Z1av() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // OGCG: %[[EXN_SLOT:.*]] = alloca ptr | |
| // OGCG: %[[EHSELECTOR_SLOT:.*]] = alloca i32 | |
| // OGCG: %[[PTR:.*]] = call {{.*}} ptr @_Znwm(i64 8) #[[OGCG_ATTR_BUILTIN_NEW:.*]] | |
| // OGCG: invoke void @_ZN1AC1Ei(ptr {{.*}} %[[PTR]], i32 5) | |
| // OGCG: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // OGCG: [[INVOKE_CONT]]: | |
| // OGCG: ret ptr %[[PTR]] | |
| // OGCG: [[UNWIND]]: | |
| // OGCG: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // OGCG: cleanup | |
| // OGCG: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // OGCG: store ptr %[[EXN_PTR]], ptr %[[EXN_SLOT]] | |
| // OGCG: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // OGCG: store i32 %[[TYPEID]], ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: call void @_ZdlPv(ptr allocptr %[[PTR]]) #[[OGCG_ATTR_BUILTIN_DEL:.*]] | |
| // OGCG: br label %[[EH_RESUME:.*]] | |
| // OGCG: [[EH_RESUME]]: | |
| // OGCG: %[[EXN_PTR:.*]] = load ptr, ptr %[[EXN_SLOT]] | |
| // OGCG: %[[EHSELECTOR:.*]] = load i32, ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR]], 0 | |
| // OGCG: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[EHSELECTOR]], 1 | |
| // OGCG: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| A *b() { | |
| extern int foo(); | |
| return new A(foo()); | |
| } | |
| // CIR: cir.func {{.*}} @_Z1bv() -> !cir.ptr<!rec_A>{{.*}} { | |
| // CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i | |
| // CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[PTR_A:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_A> | |
| // CIR: cir.store{{.*}} %[[PTR_A]], %[[NEW_RESULT]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>> | |
| // CIR: %[[FOO:.*]] = cir.call @_Z3foov() : () -> !s32i | |
| // CIR: cir.call @_ZN1AC1Ei(%[[PTR_A]], %[[FOO]]) | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: cir.call @_ZdlPv(%[[PTR]]) nothrow {builtin} : (!cir.ptr<!void>) -> () | |
| // CIR: cir.yield | |
| // CIR: } | |
| // LLVM: define {{.*}} ptr @_Z1bv() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // LLVM: %[[RETVAL:.*]] = alloca ptr | |
| // LLVM: %[[NEW_RESULT:.*]] = alloca ptr | |
| // LLVM: %[[PTR:.*]] = call noalias nonnull ptr @_Znwm(i64 8) #[[ATTR_BUILTIN_NEW]] | |
| // LLVM: br label %[[EH_SCOPE:.*]] | |
| // LLVM: [[EH_SCOPE]]: | |
| // LLVM: store ptr %[[PTR]], ptr %[[NEW_RESULT]] | |
| // LLVM: %[[FOO:.*]] = invoke i32 @_Z3foov() | |
| // LLVM: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // LLVM: [[INVOKE_CONT]]: | |
| // LLVM: invoke void @_ZN1AC1Ei(ptr {{.*}} %[[PTR]], i32 %[[FOO]]) | |
| // LLVM: to label %[[INVOKE_CONT_2:.*]] unwind label %[[UNWIND:.*]] | |
| // LLVM: [[INVOKE_CONT_2]]: | |
| // LLVM: br label %[[EH_SCOPE_END:.*]] | |
| // LLVM: [[UNWIND]]: | |
| // LLVM: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // LLVM: cleanup | |
| // LLVM: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // LLVM: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // LLVM: br label %[[EH_CLEANUP:.*]] | |
| // LLVM: [[EH_CLEANUP]]: | |
| // LLVM: %[[EXN_PTR_PHI:.*]] = phi ptr [ %[[EXN_PTR]], %[[UNWIND]] ] | |
| // LLVM: %[[TYPEID_PHI:.*]] = phi i32 [ %[[TYPEID]], %[[UNWIND]] ] | |
| // LLVM: call void @_ZdlPv(ptr %[[PTR]]) #[[ATTR_BUILTIN_DEL]] | |
| // LLVM: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR_PHI]], 0 | |
| // LLVM: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[TYPEID_PHI]], 1 | |
| // LLVM: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| // LLVM: [[EH_SCOPE_END]]: | |
| // LLVM: %[[LOAD:.*]] = load ptr, ptr %[[NEW_RESULT]] | |
| // LLVM: store ptr %[[LOAD]], ptr %[[RETVAL]] | |
| // LLVM: %[[RET:.*]] = load ptr, ptr %[[RETVAL]] | |
| // LLVM: ret ptr %[[RET]] | |
| // OGCG: define {{.*}} ptr @_Z1bv() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // OGCG: %[[EXN_SLOT:.*]] = alloca ptr | |
| // OGCG: %[[EHSELECTOR_SLOT:.*]] = alloca i32 | |
| // OGCG: %[[PTR:.*]] = call {{.*}} ptr @_Znwm(i64 8) #[[OGCG_ATTR_BUILTIN_NEW]] | |
| // OGCG: %[[FOO:.*]] = invoke i32 @_Z3foov() | |
| // OGCG: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // OGCG: [[INVOKE_CONT]]: | |
| // OGCG: invoke void @_ZN1AC1Ei(ptr {{.*}} %[[PTR]], i32 %[[FOO]]) | |
| // OGCG: to label %[[INVOKE_CONT_2:.*]] unwind label %[[UNWIND:.*]] | |
| // OGCG: [[INVOKE_CONT_2]]: | |
| // OGCG: ret ptr %[[PTR]] | |
| // OGCG: [[UNWIND]]: | |
| // OGCG: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // OGCG: cleanup | |
| // OGCG: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // OGCG: store ptr %[[EXN_PTR]], ptr %[[EXN_SLOT]] | |
| // OGCG: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // OGCG: store i32 %[[TYPEID]], ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: call void @_ZdlPv(ptr allocptr %[[PTR]]) #[[OGCG_ATTR_BUILTIN_DEL]] | |
| // OGCG: br label %[[EH_RESUME:.*]] | |
| // OGCG: [[EH_RESUME]]: | |
| // OGCG: %[[EXN_PTR:.*]] = load ptr, ptr %[[EXN_SLOT]] | |
| // OGCG: %[[EHSELECTOR:.*]] = load i32, ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR]], 0 | |
| // OGCG: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[EHSELECTOR]], 1 | |
| // OGCG: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| // Class-specific operator new/delete should not get the 'builtin' attribute, | |
| // since they are not replaceable global allocation functions. | |
| struct B { | |
| B(int); | |
| ~B(); | |
| void *operator new(__SIZE_TYPE__); | |
| void operator delete(void *) throw(); | |
| int x; | |
| }; | |
| B *c() { | |
| return new B(5); | |
| } | |
| // CIR: cir.func {{.*}} @_Z1cv() -> !cir.ptr<!rec_B>{{.*}} { | |
| // CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_B>> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_B>> | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<4> : !u64i | |
| // CIR: %[[PTR:.*]] = cir.call @_ZN1BnwEm(%[[ALLOC_SIZE]]) : (!u64i) -> !cir.ptr<!void> | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[PTR_B:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_B> | |
| // CIR: cir.store{{.*}} %[[PTR_B]], %[[NEW_RESULT]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>> | |
| // CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s32i | |
| // CIR: cir.call @_ZN1BC1Ei(%[[PTR_B]], %[[FIVE]]) | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: cir.call @_ZN1BdlEPv(%[[PTR]]) nothrow : (!cir.ptr<!void>) -> () | |
| // CIR: cir.yield | |
| // CIR: } | |
| // LLVM: define {{.*}} ptr @_Z1cv() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // LLVM: %[[RETVAL:.*]] = alloca ptr | |
| // LLVM: %[[NEW_RESULT:.*]] = alloca ptr | |
| // LLVM: %[[PTR:.*]] = call ptr @_ZN1BnwEm(i64 4) | |
| // LLVM: br label %[[EH_SCOPE:.*]] | |
| // LLVM: [[EH_SCOPE]]: | |
| // LLVM: store ptr %[[PTR]], ptr %[[NEW_RESULT]] | |
| // LLVM: invoke void @_ZN1BC1Ei(ptr {{.*}} %[[PTR]], i32 5) | |
| // LLVM: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // LLVM: [[INVOKE_CONT]]: | |
| // LLVM: br label %[[EH_SCOPE_END:.*]] | |
| // LLVM: [[UNWIND]]: | |
| // LLVM: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // LLVM: cleanup | |
| // LLVM: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // LLVM: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // LLVM: br label %[[EH_CLEANUP:.*]] | |
| // LLVM: [[EH_CLEANUP]]: | |
| // LLVM: %[[EXN_PTR_PHI:.*]] = phi ptr [ %[[EXN_PTR]], %[[UNWIND]] ] | |
| // LLVM: %[[TYPEID_PHI:.*]] = phi i32 [ %[[TYPEID]], %[[UNWIND]] ] | |
| // LLVM: call void @_ZN1BdlEPv(ptr %[[PTR]]) | |
| // LLVM: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR_PHI]], 0 | |
| // LLVM: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[TYPEID_PHI]], 1 | |
| // LLVM: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| // LLVM: [[EH_SCOPE_END]]: | |
| // LLVM: %[[LOAD:.*]] = load ptr, ptr %[[NEW_RESULT]] | |
| // LLVM: store ptr %[[LOAD]], ptr %[[RETVAL]] | |
| // LLVM: %[[RET:.*]] = load ptr, ptr %[[RETVAL]] | |
| // LLVM: ret ptr %[[RET]] | |
| // OGCG: define {{.*}} ptr @_Z1cv() {{.*}} personality ptr @__gxx_personality_v0 { | |
| // OGCG: %[[EXN_SLOT:.*]] = alloca ptr | |
| // OGCG: %[[EHSELECTOR_SLOT:.*]] = alloca i32 | |
| // OGCG: %[[PTR:.*]] = call ptr @_ZN1BnwEm(i64 4) | |
| // OGCG: invoke void @_ZN1BC1Ei(ptr {{.*}} %[[PTR]], i32 5) | |
| // OGCG: to label %[[INVOKE_CONT:.*]] unwind label %[[UNWIND:.*]] | |
| // OGCG: [[INVOKE_CONT]]: | |
| // OGCG: ret ptr %[[PTR]] | |
| // OGCG: [[UNWIND]]: | |
| // OGCG: %[[EXN:.*]] = landingpad { ptr, i32 } | |
| // OGCG: cleanup | |
| // OGCG: %[[EXN_PTR:.*]] = extractvalue { ptr, i32 } %[[EXN]], 0 | |
| // OGCG: store ptr %[[EXN_PTR]], ptr %[[EXN_SLOT]] | |
| // OGCG: %[[TYPEID:.*]] = extractvalue { ptr, i32 } %[[EXN]], 1 | |
| // OGCG: store i32 %[[TYPEID]], ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: call void @_ZN1BdlEPv(ptr %[[PTR]]) | |
| // OGCG: br label %[[EH_RESUME:.*]] | |
| // OGCG: [[EH_RESUME]]: | |
| // OGCG: %[[EXN_PTR2:.*]] = load ptr, ptr %[[EXN_SLOT]] | |
| // OGCG: %[[EHSELECTOR:.*]] = load i32, ptr %[[EHSELECTOR_SLOT]] | |
| // OGCG: %[[EXN_INSERT:.*]] = insertvalue { ptr, i32 } poison, ptr %[[EXN_PTR2]], 0 | |
| // OGCG: %[[EXN_INSERT_2:.*]] = insertvalue { ptr, i32 } %[[EXN_INSERT]], i32 %[[EHSELECTOR]], 1 | |
| // OGCG: resume { ptr, i32 } %[[EXN_INSERT_2]] | |
| struct C { | |
| C(); | |
| ~C(); | |
| }; | |
| C *test_new_delete_conditional(bool cond) { | |
| return cond ? new C : 0; | |
| } | |
| // CIR-LABEL: @_Z27test_new_delete_conditionalb | |
| // CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool> | |
| // CIR: %[[FALSE:.*]] = cir.const #false | |
| // CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]] | |
| // CIR: %[[TERN_RESULT:.*]] = cir.ternary | |
| // CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>> | |
| // CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_C>> | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i | |
| // CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) | |
| // CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]] | |
| // CIR: cir.store {{.*}}%[[ALLOC_SIZE]], %[[SIZE_SAVE]] | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[TRUE:.*]] = cir.const #true | |
| // CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]] | |
| // CIR: %[[NEW_AS_C:.*]] = cir.cast bitcast %[[NEW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_C> | |
| // CIR: cir.store{{.*}} %[[NEW_AS_C]], %[[NEW_RESULT]] | |
| // CIR: cir.call @_ZN1CC1Ev(%[[NEW_AS_C]]) | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: %[[FLAG:.*]] = cir.load {{.*}} %[[CLEANUP_COND]] | |
| // CIR: cir.if %[[FLAG]] { | |
| // CIR: %[[RESTORED_PTR:.*]] = cir.load {{.*}} %[[PTR_SAVE]] | |
| // CIR: cir.call @_ZdlPv(%[[RESTORED_PTR]]) | |
| // CIR: } | |
| // CIR: cir.yield | |
| // CIR: } | |
| // CIR: %[[TRUE_RESULT:.*]] = cir.load{{.*}} %[[NEW_RESULT]] | |
| // CIR: cir.yield %[[TRUE_RESULT]] : !cir.ptr<!rec_C> | |
| // CIR: }, false { | |
| // CIR: %[[FALSE_RESULT:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_C> | |
| // CIR: cir.yield %[[FALSE_RESULT]] : !cir.ptr<!rec_C> | |
| // CIR: }) : (!cir.bool) -> !cir.ptr<!rec_C> | |
| // LLVM-LABEL: @_Z27test_new_delete_conditionalb | |
| // LLVM: store i8 0, ptr %[[CLEANUP_FLAG:.*]], align 1 | |
| // LLVM: br i1 {{.*}}, label %[[TRUE_BB:.*]], label %[[FALSE_BB:.*]] | |
| // LLVM: [[TRUE_BB]]: | |
| // LLVM: %[[NEWP:.*]] = call noalias nonnull ptr @_Znwm(i64 1) #[[ATTR_BUILTIN_NEW]] | |
| // LLVM: store ptr %[[NEWP]], ptr %[[SAVE_PTR:.*]], align 8 | |
| // LLVM: store i8 1, ptr %[[CLEANUP_FLAG]], align 1 | |
| // LLVM: invoke void @_ZN1CC1Ev(ptr {{.*}}%[[NEWP]]) | |
| // LLVM: to label %{{.*}} unwind label %[[LPAD:.*]] | |
| // LLVM: [[LPAD]]: | |
| // LLVM: landingpad { ptr, i32 } | |
| // LLVM-NEXT: cleanup | |
| // LLVM: %[[IS_ACTIVE:.*]] = trunc i8 %{{.*}} to i1 | |
| // LLVM: br i1 %[[IS_ACTIVE]], label %[[DO_DEL:.*]], label %[[SKIP_DEL:.*]] | |
| // LLVM: [[DO_DEL]]: | |
| // LLVM: %[[LOAD_PTR:.*]] = load ptr, ptr %[[SAVE_PTR]], align 8 | |
| // LLVM: call void @_ZdlPv(ptr %[[LOAD_PTR]]) #[[ATTR_BUILTIN_DEL]] | |
| // LLVM: resume | |
| // OGCG-LABEL: @_Z27test_new_delete_conditionalb | |
| // OGCG: store i1 false, ptr %[[OG_FLAG:.*]], align 1 | |
| // OGCG: br i1 {{.*}}, label %[[OG_TRUE:.*]], label %[[OG_FALSE:.*]] | |
| // OGCG: [[OG_TRUE]]: | |
| // OGCG: %[[OG_NEWP:.*]] = call noalias nonnull ptr @_Znwm(i64 1) #[[OGCG_ATTR_BUILTIN_NEW]] | |
| // OGCG: store ptr %[[OG_NEWP]], ptr %[[OG_SAVE:.*]], align 8 | |
| // OGCG: store i1 true, ptr %[[OG_FLAG]], align 1 | |
| // OGCG: invoke void @_ZN1CC1Ev(ptr {{.*}}%[[OG_NEWP]]) | |
| // OGCG: to label %{{.*}} unwind label %[[OG_LPAD:.*]] | |
| // OGCG: [[OG_LPAD]]: | |
| // OGCG: landingpad { ptr, i32 } | |
| // OGCG-NEXT: cleanup | |
| // OGCG: %[[OG_ACTIVE:.*]] = load i1, ptr %[[OG_FLAG]], align 1 | |
| // OGCG: br i1 %[[OG_ACTIVE]], label %[[OG_DO_DEL:.*]], label %[[OG_SKIP_DEL:.*]] | |
| // OGCG: [[OG_DO_DEL]]: | |
| // OGCG: %[[OG_LOAD:.*]] = load ptr, ptr %[[OG_SAVE]], align 8 | |
| // OGCG: call void @_ZdlPv(ptr allocptr %[[OG_LOAD]]) #[[OGCG_ATTR_BUILTIN_DEL]] | |
| // OGCG: resume | |
| void *operator new(unsigned long, int); | |
| void operator delete(void *, int); | |
| C *test_new_delete_conditional_with_placement(bool cond, int tag) { | |
| return cond ? new (tag) C : 0; | |
| } | |
| // CIR-LABEL: @_Z42test_new_delete_conditional_with_placementbi | |
| // CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool> | |
| // CIR: %[[TERN_RESULT:.*]] = cir.ternary | |
| // CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>> | |
| // CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i> | |
| // CIR: %[[TAG_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!s32i> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_C>> | |
| // CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i | |
| // CIR: %[[TAG_VAL:.*]] = cir.load{{.*}} | |
| // CIR: %[[NEW_PTR:.*]] = cir.call @_Znwmi(%[[ONE]], %[[TAG_VAL]]) | |
| // CIR: cir.store{{.*}} %[[NEW_PTR]], %[[PTR_SAVE]] | |
| // CIR: cir.store{{.*}} %[[ONE]], %[[SIZE_SAVE]] | |
| // CIR: cir.cleanup.scope { | |
| // CIR: cir.store{{.*}} %[[TAG_VAL]], %[[TAG_SAVE]] | |
| // CIR: %[[TRUE:.*]] = cir.const #true | |
| // CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]] | |
| // CIR: %[[NEW_AS_C:.*]] = cir.cast bitcast %[[NEW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_C> | |
| // CIR: cir.store{{.*}} %[[NEW_AS_C]], %[[NEW_RESULT]] | |
| // CIR: cir.call @_ZN1CC1Ev(%[[NEW_AS_C]]) | |
| // CIR: } cleanup eh { | |
| // CIR: %[[FLAG:.*]] = cir.load{{.*}} %[[CLEANUP_COND]] | |
| // CIR: cir.if %[[FLAG]] { | |
| // CIR: %[[RESTORED_PTR:.*]] = cir.load {{.*}} %[[PTR_SAVE]] | |
| // CIR: %[[RESTORED_TAG:.*]] = cir.load {{.*}} %[[TAG_SAVE]] | |
| // CIR: cir.call @_ZdlPvi(%[[RESTORED_PTR]], %[[RESTORED_TAG]]) | |
| // CIR: } | |
| // CIR: cir.yield | |
| // CIR: } | |
| // CIR: %[[TRUE_RESULT:.*]] = cir.load{{.*}} %[[NEW_RESULT]] | |
| // CIR: cir.yield %[[TRUE_RESULT]] : !cir.ptr<!rec_C> | |
| // CIR: }, false { | |
| // CIR: %[[FALSE_RESULT:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_C> | |
| // CIR: cir.yield %[[FALSE_RESULT]] : !cir.ptr<!rec_C> | |
| // CIR: }) : (!cir.bool) -> !cir.ptr<!rec_C> | |
| // LLVM-LABEL: @_Z42test_new_delete_conditional_with_placementbi | |
| // LLVM: store i8 0, ptr %[[PL_FLAG:.*]], align 1 | |
| // LLVM: br i1 {{.*}}, label %[[PL_TRUE:.*]], label %[[PL_FALSE:.*]] | |
| // LLVM: [[PL_TRUE]]: | |
| // LLVM: %[[PL_TAG:.*]] = load i32, ptr %{{.*}}, align 4 | |
| // LLVM: %[[PL_NEWP:.*]] = call ptr @_Znwmi(i64 1, i32 %[[PL_TAG]]) | |
| // LLVM: store ptr %[[PL_NEWP]], ptr %[[PL_SAVE_PTR:.*]], align 8 | |
| // LLVM: store i32 %[[PL_TAG]], ptr %[[PL_SAVE_TAG:.*]], align 4 | |
| // LLVM: store i8 1, ptr %[[PL_FLAG]], align 1 | |
| // LLVM: invoke void @_ZN1CC1Ev(ptr {{.*}}%[[PL_NEWP]]) | |
| // LLVM: to label %{{.*}} unwind label %[[PL_LPAD:.*]] | |
| // LLVM: [[PL_LPAD]]: | |
| // LLVM: landingpad { ptr, i32 } | |
| // LLVM-NEXT: cleanup | |
| // LLVM: %[[PL_ACTIVE:.*]] = trunc i8 %{{.*}} to i1 | |
| // LLVM: br i1 %[[PL_ACTIVE]], label %[[PL_DO_DEL:.*]], label %[[PL_SKIP_DEL:.*]] | |
| // LLVM: [[PL_DO_DEL]]: | |
| // LLVM: %[[PL_LOAD_PTR:.*]] = load ptr, ptr %[[PL_SAVE_PTR]], align 8 | |
| // LLVM: %[[PL_LOAD_TAG:.*]] = load i32, ptr %[[PL_SAVE_TAG]], align 4 | |
| // LLVM: invoke void @_ZdlPvi(ptr %[[PL_LOAD_PTR]], i32 %[[PL_LOAD_TAG]]) | |
| // OGCG-LABEL: @_Z42test_new_delete_conditional_with_placementbi | |
| // OGCG: store i1 false, ptr %[[OGP_FLAG:.*]], align 1 | |
| // OGCG: br i1 {{.*}}, label %[[OGP_TRUE:.*]], label %[[OGP_FALSE:.*]] | |
| // OGCG: [[OGP_TRUE]]: | |
| // OGCG: %[[OGP_TAG:.*]] = load i32, ptr %{{.*}}, align 4 | |
| // OGCG: %[[OGP_NEWP:.*]] = call ptr @_Znwmi(i64 1, i32 %[[OGP_TAG]]) | |
| // OGCG: store ptr %[[OGP_NEWP]], ptr %[[OGP_SAVE_PTR:.*]], align 8 | |
| // OGCG: store i32 %[[OGP_TAG]], ptr %[[OGP_SAVE_TAG:.*]], align 4 | |
| // OGCG: store i1 true, ptr %[[OGP_FLAG]], align 1 | |
| // OGCG: invoke void @_ZN1CC1Ev(ptr {{.*}}%[[OGP_NEWP]]) | |
| // OGCG: to label %{{.*}} unwind label %[[OGP_LPAD:.*]] | |
| // OGCG: [[OGP_LPAD]]: | |
| // OGCG: landingpad { ptr, i32 } | |
| // OGCG-NEXT: cleanup | |
| // OGCG: %[[OGP_ACTIVE:.*]] = load i1, ptr %[[OGP_FLAG]], align 1 | |
| // OGCG: br i1 %[[OGP_ACTIVE]], label %[[OGP_DO_DEL:.*]], label %[[OGP_SKIP_DEL:.*]] | |
| // OGCG: [[OGP_DO_DEL]]: | |
| // OGCG: %[[OGP_LOAD_PTR:.*]] = load ptr, ptr %[[OGP_SAVE_PTR]], align 8 | |
| // OGCG: %[[OGP_LOAD_TAG:.*]] = load i32, ptr %[[OGP_SAVE_TAG]], align 4 | |
| // OGCG: invoke void @_ZdlPvi(ptr %[[OGP_LOAD_PTR]], i32 %[[OGP_LOAD_TAG]]) | |
| struct D { | |
| D(); | |
| static void operator delete(void *, unsigned long); | |
| static void operator delete[](void *, unsigned long); | |
| }; | |
| D *test_new_delete_conditional_with_size(bool cond) { | |
| return cond ? new D : 0; | |
| } | |
| // CIR-LABEL: @_Z37test_new_delete_conditional_with_sizeb | |
| // CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool> | |
| // CIR: %[[FALSE:.*]] = cir.const #false | |
| // CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]] | |
| // CIR: cir.ternary | |
| // CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>> | |
| // CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_D>> | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i | |
| // CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) | |
| // CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]] | |
| // CIR: cir.store {{.*}}%[[ALLOC_SIZE]], %[[SIZE_SAVE]] | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[TRUE:.*]] = cir.const #true | |
| // CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]] | |
| // CIR: cir.call @_ZN1DC1Ev | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: %[[FLAG:.*]] = cir.load {{.*}} %[[CLEANUP_COND]] | |
| // CIR: cir.if %[[FLAG]] { | |
| // CIR: %[[RESTORED_PTR:.*]] = cir.load {{.*}} %[[PTR_SAVE]] | |
| // CIR: %[[RESTORED_SIZE:.*]] = cir.load {{.*}} %[[SIZE_SAVE]] | |
| // CIR: cir.call @_ZN1DdlEPvm(%[[RESTORED_PTR]], %[[RESTORED_SIZE]]) | |
| // CIR: } | |
| // CIR: cir.yield | |
| // CIR: } | |
| // CIR: %[[TRUE_RESULT:.*]] = cir.load{{.*}} %[[NEW_RESULT]] | |
| // CIR: cir.yield %[[TRUE_RESULT]] : !cir.ptr<!rec_D> | |
| // CIR: }, false { | |
| // CIR: %[[FALSE_RESULT:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_D> | |
| // CIR: cir.yield %[[FALSE_RESULT]] : !cir.ptr<!rec_D> | |
| // CIR: }) : (!cir.bool) -> !cir.ptr<!rec_D> | |
| // LLVM-LABEL: @_Z37test_new_delete_conditional_with_sizeb | |
| // LLVM: store i8 0, ptr %[[SD_FLAG:.*]], align 1 | |
| // LLVM: br i1 {{.*}}, label %[[SD_TRUE:.*]], label %[[SD_FALSE:.*]] | |
| // LLVM: [[SD_TRUE]]: | |
| // LLVM: %[[SD_NEWP:.*]] = call noalias nonnull ptr @_Znwm(i64 1) | |
| // LLVM: store ptr %[[SD_NEWP]], ptr %[[SD_SAVE_PTR:.*]], align 8 | |
| // LLVM: store i64 1, ptr %[[SD_SAVE_SIZE:.*]], align 8 | |
| // LLVM: store i8 1, ptr %[[SD_FLAG]], align 1 | |
| // LLVM: invoke void @_ZN1DC1Ev(ptr {{.*}}%[[SD_NEWP]]) | |
| // LLVM: to label %{{.*}} unwind label %[[SD_LPAD:.*]] | |
| // LLVM: [[SD_LPAD]]: | |
| // LLVM: landingpad { ptr, i32 } | |
| // LLVM-NEXT: cleanup | |
| // LLVM: %[[SD_ACTIVE:.*]] = trunc i8 %{{.*}} to i1 | |
| // LLVM: br i1 %[[SD_ACTIVE]], label %[[SD_DO_DEL:.*]], label %[[SD_SKIP_DEL:.*]] | |
| // LLVM: [[SD_DO_DEL]]: | |
| // LLVM: %[[SD_LOAD_PTR:.*]] = load ptr, ptr %[[SD_SAVE_PTR]], align 8 | |
| // LLVM: %[[SD_LOAD_SIZE:.*]] = load i64, ptr %[[SD_SAVE_SIZE]], align 8 | |
| // LLVM: invoke void @_ZN1DdlEPvm(ptr %[[SD_LOAD_PTR]], i64 %[[SD_LOAD_SIZE]]) | |
| // OGCG-LABEL: @_Z37test_new_delete_conditional_with_sizeb | |
| // OGCG: store i1 false, ptr %[[OGS_FLAG:.*]], align 1 | |
| // OGCG: br i1 {{.*}}, label %[[OGS_TRUE:.*]], label %[[OGS_FALSE:.*]] | |
| // OGCG: [[OGS_TRUE]]: | |
| // OGCG: %[[OGS_NEWP:.*]] = call noalias nonnull ptr @_Znwm(i64 1) | |
| // OGCG: store ptr %[[OGS_NEWP]], ptr %[[OGS_SAVE:.*]], align 8 | |
| // OGCG: store i1 true, ptr %[[OGS_FLAG]], align 1 | |
| // OGCG: invoke void @_ZN1DC1Ev(ptr {{.*}}%[[OGS_NEWP]]) | |
| // OGCG: to label %{{.*}} unwind label %[[OGS_LPAD:.*]] | |
| // OGCG: [[OGS_LPAD]]: | |
| // OGCG: landingpad { ptr, i32 } | |
| // OGCG-NEXT: cleanup | |
| // OGCG: %[[OGS_ACTIVE:.*]] = load i1, ptr %[[OGS_FLAG]], align 1 | |
| // OGCG: br i1 %[[OGS_ACTIVE]], label %[[OGS_DO_DEL:.*]], label %[[OGS_SKIP_DEL:.*]] | |
| // OGCG: [[OGS_DO_DEL]]: | |
| // OGCG: %[[OGS_LOAD_PTR:.*]] = load ptr, ptr %[[OGS_SAVE]], align 8 | |
| // OGCG: invoke void @_ZN1DdlEPvm(ptr %[[OGS_LOAD_PTR]], i64 1) | |
| D *test_new_delete_conditional_array(bool cond, int n) { | |
| return cond ? new D[n] : 0; | |
| } | |
| // CIR-LABEL: @_Z33test_new_delete_conditional_arraybi | |
| // CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool> | |
| // CIR: %[[FALSE:.*]] = cir.const #false | |
| // CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]] | |
| // CIR: cir.ternary | |
| // CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>> | |
| // CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i> | |
| // CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_D>> | |
| // CIR: %[[N:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i | |
| // CIR: %[[N_EXT:.*]] = cir.cast integral %[[N]] : !s32i -> !s64i | |
| // CIR: %result, %overflow = cir.add.overflow %{{.*}}, %{{.*}} : !u64i -> !u64i | |
| // CIR: %[[ALLOC_SIZE:.*]] = cir.select | |
| // CIR: %[[NEW_PTR:.*]] = cir.call @_Znam(%[[ALLOC_SIZE]]) | |
| // CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]] | |
| // CIR: cir.store {{.*}}%[[ALLOC_SIZE]], %[[SIZE_SAVE]] | |
| // CIR: cir.cleanup.scope { | |
| // CIR: %[[TRUE:.*]] = cir.const #true | |
| // CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]] | |
| // CIR: cir.call @_ZN1DC1Ev | |
| // CIR: cir.yield | |
| // CIR: } cleanup eh { | |
| // CIR: %[[FLAG:.*]] = cir.load {{.*}} %[[CLEANUP_COND]] | |
| // CIR: cir.if %[[FLAG]] { | |
| // CIR: %[[RESTORED_PTR:.*]] = cir.load {{.*}} %[[PTR_SAVE]] | |
| // CIR: %[[RESTORED_SIZE:.*]] = cir.load {{.*}} %[[SIZE_SAVE]] | |
| // CIR: cir.call @_ZN1DdaEPvm(%[[RESTORED_PTR]], %[[RESTORED_SIZE]]) | |
| // CIR: } | |
| // CIR: cir.yield | |
| // CIR: } | |
| // CIR: %[[TRUE_RESULT:.*]] = cir.load{{.*}} %[[NEW_RESULT]] | |
| // CIR: cir.yield %[[TRUE_RESULT]] : !cir.ptr<!rec_D> | |
| // CIR: }, false { | |
| // CIR: %[[FALSE_RESULT:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_D> | |
| // CIR: cir.yield %[[FALSE_RESULT]] : !cir.ptr<!rec_D> | |
| // CIR: }) : (!cir.bool) -> !cir.ptr<!rec_D> | |
| // LLVM-LABEL: @_Z33test_new_delete_conditional_arraybi | |
| // LLVM: store i8 0, ptr %[[ARR_FLAG:.*]], align 1 | |
| // LLVM: br i1 {{.*}}, label %[[ARR_TRUE:.*]], label %[[ARR_FALSE:.*]] | |
| // LLVM: [[ARR_TRUE]]: | |
| // LLVM: %[[ARR_ALLOC_SIZE:.*]] = select i1 %{{.*}}, i64 -1, i64 %{{.*}} | |
| // LLVM: %[[ARR_NEWP:.*]] = call noalias nonnull ptr @_Znam(i64 %[[ARR_ALLOC_SIZE]]) | |
| // LLVM: store ptr %[[ARR_NEWP]], ptr %[[ARR_SAVE_PTR:.*]], align 8 | |
| // LLVM: store i64 %[[ARR_ALLOC_SIZE]], ptr %[[ARR_SAVE_SIZE:.*]], align 8 | |
| // LLVM: store i8 1, ptr %[[ARR_FLAG]], align 1 | |
| // LLVM: invoke void @_ZN1DC1Ev | |
| // LLVM: [[ARR_LPAD:.*]]: | |
| // LLVM: landingpad { ptr, i32 } | |
| // LLVM-NEXT: cleanup | |
| // LLVM: %[[ARR_ACTIVE:.*]] = trunc i8 %{{.*}} to i1 | |
| // LLVM: br i1 %[[ARR_ACTIVE]], label %[[ARR_DO_DEL:.*]], label %[[ARR_SKIP_DEL:.*]] | |
| // LLVM: [[ARR_DO_DEL]]: | |
| // LLVM: %[[ARR_LOAD_PTR:.*]] = load ptr, ptr %[[ARR_SAVE_PTR]], align 8 | |
| // LLVM: %[[ARR_LOAD_SIZE:.*]] = load i64, ptr %[[ARR_SAVE_SIZE]], align 8 | |
| // LLVM: invoke void @_ZN1DdaEPvm(ptr %[[ARR_LOAD_PTR]], i64 %[[ARR_LOAD_SIZE]]) | |
| // OGCG-LABEL: @_Z33test_new_delete_conditional_arraybi | |
| // OGCG: store i1 false, ptr %[[OGA_FLAG:.*]], align 1 | |
| // OGCG: br i1 {{.*}}, label %[[OGA_TRUE:.*]], label %[[OGA_FALSE:.*]] | |
| // OGCG: [[OGA_TRUE]]: | |
| // OGCG: %[[OGA_ALLOC_SIZE:.*]] = select i1 %{{.*}}, i64 -1, i64 %{{.*}} | |
| // OGCG: %[[OGA_NEWP:.*]] = call noalias nonnull ptr @_Znam(i64 %[[OGA_ALLOC_SIZE]]) | |
| // OGCG: store ptr %[[OGA_NEWP]], ptr %[[OGA_SAVE_PTR:.*]], align 8 | |
| // OGCG: store i64 %[[OGA_ALLOC_SIZE]], ptr %[[OGA_SAVE_SIZE:.*]], align 8 | |
| // OGCG: store i1 true, ptr %[[OGA_FLAG]], align 1 | |
| // OGCG: invoke void @_ZN1DC1Ev | |
| // OGCG: [[OGA_LPAD:.*]]: | |
| // OGCG: landingpad { ptr, i32 } | |
| // OGCG-NEXT: cleanup | |
| // OGCG: %[[OGA_ACTIVE:.*]] = load i1, ptr %[[OGA_FLAG]], align 1 | |
| // OGCG: br i1 %[[OGA_ACTIVE]], label %[[OGA_DO_DEL:.*]], label %[[OGA_SKIP_DEL:.*]] | |
| // OGCG: [[OGA_DO_DEL]]: | |
| // OGCG: %[[OGA_LOAD_PTR:.*]] = load ptr, ptr %[[OGA_SAVE_PTR]], align 8 | |
| // OGCG: %[[OGA_LOAD_SIZE:.*]] = load i64, ptr %[[OGA_SAVE_SIZE]], align 8 | |
| // OGCG: invoke void @_ZN1DdaEPvm(ptr %[[OGA_LOAD_PTR]], i64 %[[OGA_LOAD_SIZE]]) | |
| // LLVM-DAG: attributes #[[ATTR_BUILTIN_NEW]] = {{{.*}}builtin{{.*}}memory(inaccessiblemem: readwrite, errnomem: write){{.*}}} | |
| // LLVM-DAG: attributes #[[ATTR_BUILTIN_DEL]] = {{{.*}}builtin{{.*}}} | |
| // OGCG-DAG: attributes #[[OGCG_ATTR_BUILTIN_NEW]] = {{{.*}}builtin{{.*}}} | |
| // OGCG-DAG: attributes #[[OGCG_ATTR_BUILTIN_DEL]] = {{{.*}}builtin{{.*}}} |