From a9d8deb29d606820d7323dbfd95ab390e09349c0 Mon Sep 17 00:00:00 2001 From: AZero13 Date: Thu, 23 Oct 2025 14:39:18 -0400 Subject: [PATCH] [CGObjC] Allow clang.arc.attachedcall on -O0 It is supported in GlobalISel there. It is not supported on X86 GlobalISel. --- clang/lib/CodeGen/CGObjC.cpp | 11 +- clang/test/CodeGenObjC/arc-arm.m | 23 +- clang/test/CodeGenObjC/arc-foreach.m | 186 +++++++------- clang/test/CodeGenObjC/arc-property.m | 6 +- .../CodeGenObjC/arc-related-result-type.m | 6 +- clang/test/CodeGenObjC/arc-unopt.m | 14 +- clang/test/CodeGenObjC/arc-unsafeclaim.m | 50 +++- clang/test/CodeGenObjC/arc-with-atthrow.m | 10 +- .../test/CodeGenObjC/ns_consume_null_check.m | 14 +- .../objc-arc-container-subscripting.m | 10 +- clang/test/CodeGenObjC/os_log.m | 32 +-- .../auto-release-result-assert.mm | 18 +- .../inheriting-constructor-cleanup.mm | 4 +- llvm/lib/Target/AArch64/AArch64FastISel.cpp | 5 + llvm/lib/Target/X86/X86FastISel.cpp | 5 + llvm/test/CodeGen/AArch64/call-rv-marker.ll | 231 ++++++++++++++++++ 16 files changed, 466 insertions(+), 159 deletions(-) diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp index 10aad2e26938d..60eea7d01878a 100644 --- a/clang/lib/CodeGen/CGObjC.cpp +++ b/clang/lib/CodeGen/CGObjC.cpp @@ -2415,9 +2415,7 @@ static llvm::Value *emitOptimizedARCReturnCall(llvm::Value *value, emitAutoreleasedReturnValueMarker(CGF); // Add operand bundle "clang.arc.attachedcall" to the call instead of emitting - // retainRV or claimRV calls in the IR. We currently do this only when the - // optimization level isn't -O0 since global-isel, which is currently run at - // -O0, doesn't know about the operand bundle. + // retainRV or claimRV calls in the IR. ObjCEntrypoints &EPs = CGF.CGM.getObjCEntrypoints(); llvm::Function *&EP = IsRetainRV ? EPs.objc_retainAutoreleasedReturnValue @@ -2429,11 +2427,8 @@ static llvm::Value *emitOptimizedARCReturnCall(llvm::Value *value, llvm::Triple::ArchType Arch = CGF.CGM.getTriple().getArch(); - // FIXME: Do this on all targets and at -O0 too. This can be enabled only if - // the target backend knows how to handle the operand bundle. - if (CGF.CGM.getCodeGenOpts().OptimizationLevel > 0 && - (Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32 || - Arch == llvm::Triple::x86_64)) { + if (Arch == llvm::Triple::x86_64 || + (Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32)) { llvm::Value *bundleArgs[] = {EP}; llvm::OperandBundleDef OB("clang.arc.attachedcall", bundleArgs); auto *oldCall = cast(value); diff --git a/clang/test/CodeGenObjC/arc-arm.m b/clang/test/CodeGenObjC/arc-arm.m index 6105644c2d684..ed2ff7e51f047 100644 --- a/clang/test/CodeGenObjC/arc-arm.m +++ b/clang/test/CodeGenObjC/arc-arm.m @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -triple armv7-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple arm64-apple-ios -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple arm64-apple-ios -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s -check-prefix=ARM64-ATTACHED // use an autorelease marker on ARM64. @@ -7,6 +7,11 @@ id test0(void) { extern id test0_helper(void); // CHECK: [[T0:%.*]] = call [[CC:(arm_aapcscc )?]]ptr @test0_helper() // CHECK-NEXT: ret ptr [[T0]] + // ARM64-ATTACHED: %call1 = call ptr @test0_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] + // ARM64-ATTACHED: call void asm sideeffect "mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue", ""() + // ARM64-ATTACHED: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + // ARM64-ATTACHED: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #2 + // ARM64-ATTACHED: ret ptr %0 return test0_helper(); } @@ -18,6 +23,12 @@ void test1(void) { // CHECK-NEXT: store ptr [[T1]], // CHECK-NEXT: call [[CC]]void @llvm.objc.storeStrong( // CHECK-NEXT: ret void + // ARM64-ATTACHED: %call1 = call ptr @test1_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] + // ARM64-ATTACHED: call void asm sideeffect "mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue", ""() + // ARM64-ATTACHED: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + // ARM64-ATTACHED: store ptr %call1, + // ARM64-ATTACHED: call void @llvm.objc.storeStrong( + // ARM64-ATTACHED: ret void id x = test1_helper(); } @@ -26,6 +37,11 @@ void test1(void) { extern A *test2_helper(void); // CHECK: [[T0:%.*]] = call [[CC]]ptr @test2_helper() // CHECK-NEXT: ret ptr [[T0]] + // ARM64-ATTACHED: %call1 = call ptr @test2_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] + // ARM64-ATTACHED: call void asm sideeffect "mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue", ""() + // ARM64-ATTACHED: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + // ARM64-ATTACHED: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #2 + // ARM64-ATTACHED: ret ptr %0 return test2_helper(); } @@ -33,5 +49,10 @@ id test3(void) { extern A *test3_helper(void); // CHECK: [[T0:%.*]] = call [[CC]]ptr @test3_helper() // CHECK-NEXT: ret ptr [[T0]] + // ARM64-ATTACHED: %call1 = call ptr @test3_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] + // ARM64-ATTACHED: call void asm sideeffect "mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue", ""() + // ARM64-ATTACHED: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + // ARM64-ATTACHED: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #2 + // ARM64-ATTACHED: ret ptr %0 return test3_helper(); } diff --git a/clang/test/CodeGenObjC/arc-foreach.m b/clang/test/CodeGenObjC/arc-foreach.m index 35620fce20485..557e75879e4c0 100644 --- a/clang/test/CodeGenObjC/arc-foreach.m +++ b/clang/test/CodeGenObjC/arc-foreach.m @@ -20,12 +20,12 @@ void test0(NSArray *array) { } } -// CHECK-LP64-LABEL: define{{.*}} void @test0( -// CHECK-LP64: [[ARRAY:%.*]] = alloca ptr, -// CHECK-LP64-NEXT: [[X:%.*]] = alloca ptr, -// CHECK-LP64-NEXT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], -// CHECK-LP64-NEXT: [[BUFFER:%.*]] = alloca [16 x ptr], align 8 -// CHECK-LP64-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], +// CHECK-LP64-ATTACHED-LABEL: define{{.*}} void @test0( +// CHECK-LP64-ATTACHED: [[ARRAY:%.*]] = alloca ptr, +// CHECK-LP64-ATTACHED-NEXT: [[X:%.*]] = alloca ptr, +// CHECK-LP64-ATTACHED-NEXT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], +// CHECK-LP64-ATTACHED-NEXT: [[BUFFER:%.*]] = alloca [16 x ptr], align 8 +// CHECK-LP64-ATTACHED-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], // CHECK-LP64-OPT-LABEL: define{{.*}} void @test0 // CHECK-LP64-OPT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], align 8 @@ -33,57 +33,57 @@ void test0(NSArray *array) { // CHECK-LP64-OPT-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8 // Initialize 'array'. -// CHECK-LP64-NEXT: store ptr null, ptr [[ARRAY]] -// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr {{%.*}}) [[NUW:#[0-9]+]] +// CHECK-LP64-ATTACHED-NEXT: store ptr null, ptr [[ARRAY]] +// CHECK-LP64-ATTACHED-NEXT: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr {{%.*}}) [[NUW:#[0-9]+]] // Initialize the fast enumaration state. -// CHECK-LP64-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[STATE]], i8 0, i64 64, i1 false) +// CHECK-LP64-ATTACHED-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[STATE]], i8 0, i64 64, i1 false) // Evaluate the collection expression and retain. -// CHECK-LP64-NEXT: [[T0:%.*]] = load ptr, ptr [[ARRAY]], align 8 -// CHECK-LP64-NEXT: [[SAVED_ARRAY:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]]) +// CHECK-LP64-ATTACHED-NEXT: [[T0:%.*]] = load ptr, ptr [[ARRAY]], align 8 +// CHECK-LP64-ATTACHED-NEXT: [[SAVED_ARRAY:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]]) // Call the enumeration method. -// CHECK-LP64-NEXT: [[T1:%.*]] = load ptr, ptr @OBJC_SELECTOR_REFERENCES_ -// CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 @objc_msgSend(ptr [[SAVED_ARRAY]], ptr [[T1]], ptr [[STATE]], ptr [[BUFFER]], i64 16) +// CHECK-LP64-ATTACHED-NEXT: [[T1:%.*]] = load ptr, ptr @OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-ATTACHED-NEXT: [[SIZE:%.*]] = call i64 @objc_msgSend(ptr [[SAVED_ARRAY]], ptr [[T1]], ptr [[STATE]], ptr [[BUFFER]], i64 16) // Check for a nonzero result. -// CHECK-LP64-NEXT: [[T0:%.*]] = icmp eq i64 [[SIZE]], 0 -// CHECK-LP64-NEXT: br i1 [[T0]] - -// CHECK-LP64: [[T0:%.*]] = getelementptr inbounds nuw [[STATE_T]], ptr [[STATE]], i32 0, i32 1 -// CHECK-LP64-NEXT: [[T1:%.*]] = load ptr, ptr [[T0]] -// CHECK-LP64-NEXT: [[T2:%.*]] = getelementptr inbounds ptr, ptr [[T1]], i64 -// CHECK-LP64-NEXT: [[T3:%.*]] = load ptr, ptr [[T2]] -// CHECK-LP64-NEXT: store ptr [[T3]], ptr [[X]] - -// CHECK-LP64: [[CAPTURED:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr [[BLOCK]], i32 0, i32 5 -// CHECK-LP64-NEXT: [[T1:%.*]] = load ptr, ptr [[X]] -// CHECK-LP64-NEXT: [[T2:%.*]] = call ptr @llvm.objc.retain(ptr [[T1]]) -// CHECK-LP64-NEXT: store ptr [[T2]], ptr [[CAPTURED]] -// CHECK-LP64-NEXT: call void @use_block(ptr [[BLOCK]]) -// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(ptr [[CAPTURED]], ptr null) -// CHECK-LP64-NOT: call void (...) @llvm.objc.clang.arc.use( +// CHECK-LP64-ATTACHED-NEXT: [[T0:%.*]] = icmp eq i64 [[SIZE]], 0 +// CHECK-LP64-ATTACHED-NEXT: br i1 [[T0]] + +// CHECK-LP64-ATTACHED: [[T0:%.*]] = getelementptr inbounds nuw [[STATE_T]], ptr [[STATE]], i32 0, i32 1 +// CHECK-LP64-ATTACHED-NEXT: [[T1:%.*]] = load ptr, ptr [[T0]] +// CHECK-LP64-ATTACHED-NEXT: [[T2:%.*]] = getelementptr inbounds ptr, ptr [[T1]], i64 +// CHECK-LP64-ATTACHED-NEXT: [[T3:%.*]] = load ptr, ptr [[T2]] +// CHECK-LP64-ATTACHED-NEXT: store ptr [[T3]], ptr [[X]] + +// CHECK-LP64-ATTACHED: [[CAPTURED:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr [[BLOCK]], i32 0, i32 5 +// CHECK-LP64-ATTACHED-NEXT: [[T1:%.*]] = load ptr, ptr [[X]] +// CHECK-LP64-ATTACHED-NEXT: [[T2:%.*]] = call ptr @llvm.objc.retain(ptr [[T1]]) +// CHECK-LP64-ATTACHED-NEXT: store ptr [[T2]], ptr [[CAPTURED]] +// CHECK-LP64-ATTACHED-NEXT: call void @use_block(ptr [[BLOCK]]) +// CHECK-LP64-ATTACHED-NEXT: call void @llvm.objc.storeStrong(ptr [[CAPTURED]], ptr null) +// CHECK-LP64-ATTACHED-NOT: call void (...) @llvm.objc.clang.arc.use( // CHECK-LP64-OPT: [[D0:%.*]] = getelementptr inbounds nuw i8, ptr [[BLOCK]], i64 32 // CHECK-LP64-OPT: [[CAPTURE:%.*]] = load ptr, ptr [[D0]] // CHECK-LP64-OPT: call void (...) @llvm.objc.clang.arc.use(ptr [[CAPTURE]]) -// CHECK-LP64: [[T1:%.*]] = load ptr, ptr @OBJC_SELECTOR_REFERENCES_ -// CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 @objc_msgSend(ptr [[SAVED_ARRAY]], ptr [[T1]], ptr [[STATE]], ptr [[BUFFER]], i64 16) +// CHECK-LP64-ATTACHED: [[T1:%.*]] = load ptr, ptr @OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-ATTACHED-NEXT: [[SIZE:%.*]] = call i64 @objc_msgSend(ptr [[SAVED_ARRAY]], ptr [[T1]], ptr [[STATE]], ptr [[BUFFER]], i64 16) // Release the array. -// CHECK-LP64: call void @llvm.objc.release(ptr [[SAVED_ARRAY]]) +// CHECK-LP64-ATTACHED: call void @llvm.objc.release(ptr [[SAVED_ARRAY]]) // Destroy 'array'. -// CHECK-LP64: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr null) -// CHECK-LP64-NEXT: ret void +// CHECK-LP64-ATTACHED: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr null) +// CHECK-LP64-ATTACHED-NEXT: ret void -// CHECK-LP64-LABEL: define internal void @__test0_block_invoke -// CHECK-LP64-NOT: ret -// CHECK-LP64: [[T0:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr {{%.*}}, i32 0, i32 5 -// CHECK-LP64-NEXT: [[T2:%.*]] = load ptr, ptr [[T0]], align 8 -// CHECK-LP64-NEXT: call void @use(ptr [[T2]]) +// CHECK-LP64-ATTACHED-LABEL: define internal void @__test0_block_invoke +// CHECK-LP64-ATTACHED-NOT: ret +// CHECK-LP64-ATTACHED: [[T0:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr {{%.*}}, i32 0, i32 5 +// CHECK-LP64-ATTACHED-NEXT: [[T2:%.*]] = load ptr, ptr [[T0]], align 8 +// CHECK-LP64-ATTACHED-NEXT: call void @use(ptr [[T2]]) void test1(NSArray *array) { for (__weak id x in array) { @@ -91,24 +91,24 @@ void test1(NSArray *array) { } } -// CHECK-LP64-LABEL: define{{.*}} void @test1( -// CHECK-LP64: alloca ptr, -// CHECK-LP64-NEXT: [[X:%.*]] = alloca ptr, -// CHECK-LP64-NEXT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], -// CHECK-LP64-NEXT: alloca [16 x ptr], align 8 -// CHECK-LP64-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], - -// CHECK-LP64: [[T0:%.*]] = getelementptr inbounds nuw [[STATE_T]], ptr [[STATE]], i32 0, i32 1 -// CHECK-LP64-NEXT: [[T1:%.*]] = load ptr, ptr [[T0]] -// CHECK-LP64-NEXT: [[T2:%.*]] = getelementptr inbounds ptr, ptr [[T1]], i64 -// CHECK-LP64-NEXT: [[T3:%.*]] = load ptr, ptr [[T2]] -// CHECK-LP64-NEXT: call ptr @llvm.objc.initWeak(ptr [[X]], ptr [[T3]]) - -// CHECK-LP64: [[T0:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr [[BLOCK]], i32 0, i32 5 -// CHECK-LP64: call void @llvm.objc.copyWeak(ptr [[T0]], ptr [[X]]) -// CHECK-LP64: call void @use_block -// CHECK-LP64-NEXT: call void @llvm.objc.destroyWeak(ptr [[T0]]) -// CHECK-LP64-NEXT: call void @llvm.objc.destroyWeak(ptr [[X]]) +// CHECK-LP64-ATTACHED-LABEL: define{{.*}} void @test1( +// CHECK-LP64-ATTACHED: alloca ptr, +// CHECK-LP64-ATTACHED-NEXT: [[X:%.*]] = alloca ptr, +// CHECK-LP64-ATTACHED-NEXT: [[STATE:%.*]] = alloca [[STATE_T:%.*]], +// CHECK-LP64-ATTACHED-NEXT: alloca [16 x ptr], align 8 +// CHECK-LP64-ATTACHED-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], + +// CHECK-LP64-ATTACHED: [[T0:%.*]] = getelementptr inbounds nuw [[STATE_T]], ptr [[STATE]], i32 0, i32 1 +// CHECK-LP64-ATTACHED-NEXT: [[T1:%.*]] = load ptr, ptr [[T0]] +// CHECK-LP64-ATTACHED-NEXT: [[T2:%.*]] = getelementptr inbounds ptr, ptr [[T1]], i64 +// CHECK-LP64-ATTACHED-NEXT: [[T3:%.*]] = load ptr, ptr [[T2]] +// CHECK-LP64-ATTACHED-NEXT: call ptr @llvm.objc.initWeak(ptr [[X]], ptr [[T3]]) + +// CHECK-LP64-ATTACHED: [[T0:%.*]] = getelementptr inbounds nuw [[BLOCK_T]], ptr [[BLOCK]], i32 0, i32 5 +// CHECK-LP64-ATTACHED: call void @llvm.objc.copyWeak(ptr [[T0]], ptr [[X]]) +// CHECK-LP64-ATTACHED: call void @use_block +// CHECK-LP64-ATTACHED-NEXT: call void @llvm.objc.destroyWeak(ptr [[T0]]) +// CHECK-LP64-ATTACHED-NEXT: call void @llvm.objc.destroyWeak(ptr [[X]]) @interface Test2 - (NSArray *) array; @@ -120,19 +120,19 @@ void test2(Test2 *a) { } // CHECK-LP64-LABEL: define{{.*}} void @test2( -// CHECK-LP64: [[T0:%.*]] = call ptr @objc_msgSend( -// CHECK-LP64-NEXT: [[T2:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) +// CHECK-LP64: %call1 = call ptr @objc_msgSend(ptr %0, ptr %1) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-LP64: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 // Make sure it's not immediately released before starting the iteration. // CHECK-LP64-NEXT: load ptr, ptr @OBJC_SELECTOR_REFERENCES_ // CHECK-LP64-NEXT: @objc_msgSend -// CHECK-LP64: @objc_enumerationMutation +// CHECK-LP64-ATTACHED: @objc_enumerationMutation -// CHECK-LP64: load ptr, ptr @OBJC_SELECTOR_REFERENCES_ -// CHECK-LP64-NEXT: @objc_msgSend +// CHECK-LP64-ATTACHED: load ptr, ptr @OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-ATTACHED-NEXT: @objc_msgSend -// CHECK-LP64: call void @llvm.objc.release(ptr [[T2]]) +// CHECK-LP64-ATTACHED: call void @llvm.objc.release(ptr [[T2]]) // Check that the 'continue' label is positioned appropriately @@ -143,16 +143,16 @@ void test3(NSArray *array) { use(x); } - // CHECK-LP64-LABEL: define{{.*}} void @test3( - // CHECK-LP64: [[ARRAY:%.*]] = alloca ptr, align 8 - // CHECK-LP64-NEXT: [[X:%.*]] = alloca ptr, align 8 - // CHECK-LP64: [[T0:%.*]] = load ptr, ptr [[X]], align 8 - // CHECK-LP64-NEXT: [[T1:%.*]] = icmp ne ptr [[T0]], null - // CHECK-LP64-NEXT: br i1 [[T1]], - // CHECK-LP64: br label [[L:%[^ ]+]] - // CHECK-LP64: [[T0:%.*]] = load ptr, ptr [[X]], align 8 - // CHECK-LP64-NEXT: call void @use(ptr [[T0]]) - // CHECK-LP64-NEXT: br label [[L]] + // CHECK-LP64-ATTACHED-LABEL: define{{.*}} void @test3( + // CHECK-LP64-ATTACHED: [[ARRAY:%.*]] = alloca ptr, align 8 + // CHECK-LP64-ATTACHED-NEXT: [[X:%.*]] = alloca ptr, align 8 + // CHECK-LP64-ATTACHED: [[T0:%.*]] = load ptr, ptr [[X]], align 8 + // CHECK-LP64-ATTACHED-NEXT: [[T1:%.*]] = icmp ne ptr [[T0]], null + // CHECK-LP64-ATTACHED-NEXT: br i1 [[T1]], + // CHECK-LP64-ATTACHED: br label [[L:%[^ ]+]] + // CHECK-LP64-ATTACHED: [[T0:%.*]] = load ptr, ptr [[X]], align 8 + // CHECK-LP64-ATTACHED-NEXT: call void @use(ptr [[T0]]) + // CHECK-LP64-ATTACHED-NEXT: br label [[L]] } @interface NSObject @end @@ -178,36 +178,36 @@ - (void) foo2 { } @end -// CHECK-LP64-LABEL: define internal void @"\01-[I1 foo2]"( -// CHECK-LP64: [[SELF_ADDR:%.*]] = alloca ptr, -// CHECK-LP64: [[BLOCK:%.*]] = alloca <{ ptr, i32, i32, ptr, ptr, ptr }>, -// CHECK-LP64: store ptr %self, ptr [[SELF_ADDR]] -// CHECK-LP64: [[BC:%.*]] = getelementptr inbounds nuw <{ ptr, i32, i32, ptr, ptr, ptr }>, ptr [[BLOCK]], i32 0, i32 5 -// CHECK-LP64: [[T1:%.*]] = load ptr, ptr [[SELF_ADDR]] -// CHECK-LP64: call ptr @llvm.objc.retain(ptr [[T1]]) +// CHECK-LP64-ATTACHED-LABEL: define internal void @"\01-[I1 foo2]"( +// CHECK-LP64-ATTACHED: [[SELF_ADDR:%.*]] = alloca ptr, +// CHECK-LP64-ATTACHED: [[BLOCK:%.*]] = alloca <{ ptr, i32, i32, ptr, ptr, ptr }>, +// CHECK-LP64-ATTACHED: store ptr %self, ptr [[SELF_ADDR]] +// CHECK-LP64-ATTACHED: [[BC:%.*]] = getelementptr inbounds nuw <{ ptr, i32, i32, ptr, ptr, ptr }>, ptr [[BLOCK]], i32 0, i32 5 +// CHECK-LP64-ATTACHED: [[T1:%.*]] = load ptr, ptr [[SELF_ADDR]] +// CHECK-LP64-ATTACHED: call ptr @llvm.objc.retain(ptr [[T1]]) // CHECK-LP64-OPT-LABEL: define internal void @"\01-[I1 foo2]"( // CHECK-LP64-OPT: ptr %self // CHECK-LP64-OPT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], // CHECK-LP64-OPT: [[T0:%.*]] = getelementptr inbounds nuw i8, ptr [[BLOCK]], i64 32 -// CHECK-LP64: call void @llvm.objc.storeStrong(ptr [[BC]], ptr null) -// CHECK-LP64-NOT: call void (...) @llvm.objc.clang.arc.use(ptr [[BC]]) -// CHECK-LP64: switch i32 {{%.*}}, label %[[UNREACHABLE:.*]] [ -// CHECK-LP64-NEXT: i32 0, label %[[CLEANUP_CONT:.*]] -// CHECK-LP64-NEXT: i32 2, label %[[FORCOLL_END:.*]] -// CHECK-LP64-NEXT: ] +// CHECK-LP64-ATTACHED: call void @llvm.objc.storeStrong(ptr [[BC]], ptr null) +// CHECK-LP64-ATTACHED-NOT: call void (...) @llvm.objc.clang.arc.use(ptr [[BC]]) +// CHECK-LP64-ATTACHED: switch i32 {{%.*}}, label %[[UNREACHABLE:.*]] [ +// CHECK-LP64-ATTACHED-NEXT: i32 0, label %[[CLEANUP_CONT:.*]] +// CHECK-LP64-ATTACHED-NEXT: i32 2, label %[[FORCOLL_END:.*]] +// CHECK-LP64-ATTACHED-NEXT: ] // CHECK-LP64-OPT: [[T5:%.*]] = load ptr, ptr [[T0]] // CHECK-LP64-OPT: call void (...) @llvm.objc.clang.arc.use(ptr [[T5]]) -// CHECK-LP64: {{^|:}}[[CLEANUP_CONT]] -// CHECK-LP64-NEXT: br label %[[FORCOLL_END]] +// CHECK-LP64-ATTACHED: {{^|:}}[[CLEANUP_CONT]] +// CHECK-LP64-ATTACHED-NEXT: br label %[[FORCOLL_END]] -// CHECK-LP64: {{^|:}}[[FORCOLL_END]] -// CHECK-LP64-NEXT: ret void +// CHECK-LP64-ATTACHED: {{^|:}}[[FORCOLL_END]] +// CHECK-LP64-ATTACHED-NEXT: ret void -// CHECK-LP64: {{^|:}}[[UNREACHABLE]] -// CHECK-LP64-NEXT: unreachable +// CHECK-LP64-ATTACHED: {{^|:}}[[UNREACHABLE]] +// CHECK-LP64-ATTACHED-NEXT: unreachable -// CHECK-LP64: attributes [[NUW]] = { nounwind } +// CHECK-LP64-ATTACHED: attributes [[NUW]] = { nounwind } diff --git a/clang/test/CodeGenObjC/arc-property.m b/clang/test/CodeGenObjC/arc-property.m index 3209993cc6d32..42e838042ef7f 100644 --- a/clang/test/CodeGenObjC/arc-property.m +++ b/clang/test/CodeGenObjC/arc-property.m @@ -104,9 +104,9 @@ - (id) copyMachine { return test3_helper(); } // CHECK: define internal ptr @"\01-[Test3 copyMachine]"( -// CHECK: [[T0:%.*]] = call ptr @test3_helper() -// CHECK-NEXT: [[T1:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) -// CHECK-NEXT: ret ptr [[T1]] +// CHECK: %call1 = call ptr @test3_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: ret ptr %call1 - (void) setCopyMachine: (id) x {} @end diff --git a/clang/test/CodeGenObjC/arc-related-result-type.m b/clang/test/CodeGenObjC/arc-related-result-type.m index 3bb3dfb60636f..83d3cc89bc2b1 100644 --- a/clang/test/CodeGenObjC/arc-related-result-type.m +++ b/clang/test/CodeGenObjC/arc-related-result-type.m @@ -13,9 +13,9 @@ void test0(Test0 *val) { // CHECK-NEXT: call void @llvm.objc.storeStrong( // CHECK-NEXT: load ptr, ptr [[VAL]], // CHECK-NEXT: load -// CHECK-NEXT: [[T0:%.*]] = call ptr -// CHECK-NEXT: [[T1:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) -// CHECK-NEXT: store ptr [[T1]], ptr [[X]] +// CHECK-NEXT: %call1 = call ptr @objc_msgSend(ptr noundef %0, ptr noundef %1) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK-NEXT: store ptr %call1, ptr %x, align 8 // CHECK-NEXT: call void @llvm.objc.storeStrong(ptr [[X]], ptr null) // CHECK-NEXT: call void @llvm.objc.storeStrong(ptr [[VAL]], ptr null) // CHECK-NEXT: ret void diff --git a/clang/test/CodeGenObjC/arc-unopt.m b/clang/test/CodeGenObjC/arc-unopt.m index d86e2bffdcdde..fcee0edd6317e 100644 --- a/clang/test/CodeGenObjC/arc-unopt.m +++ b/clang/test/CodeGenObjC/arc-unopt.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -o - %s | FileCheck %s // A test to ensure that we generate fused calls at -O0. @@ -31,8 +31,10 @@ void test2(void) { id test3(void) { extern id test3_helper(void); - // CHECK: [[T0:%.*]] = call ptr @test3_helper() - // CHECK-NEXT: ret ptr [[T0]] +// CHECK: %call1 = call ptr @test3_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #1 +// CHECK: ret ptr %0 return test3_helper(); } @@ -40,8 +42,10 @@ @interface Test4 { id x; } @end @interface Test4_sub : Test4 { id y; } @end Test4 *test4(void) { extern Test4_sub *test4_helper(void); - // CHECK: [[T0:%.*]] = call ptr @test4_helper() - // CHECK-NEXT: ret ptr [[T0]] +// CHECK: %call1 = call ptr @test4_helper() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #1 +// CHECK: ret ptr %0 return test4_helper(); } diff --git a/clang/test/CodeGenObjC/arc-unsafeclaim.m b/clang/test/CodeGenObjC/arc-unsafeclaim.m index 9c2b215df276f..793bc57ad3f0f 100644 --- a/clang/test/CodeGenObjC/arc-unsafeclaim.m +++ b/clang/test/CodeGenObjC/arc-unsafeclaim.m @@ -1,5 +1,5 @@ // Make sure it works on x86-64. -// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-runtime=macosx-10.11 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-UNOPTIMIZED -check-prefix=NOTAIL-CALL +// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-runtime=macosx-10.11 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=X86-ATTACHED-CALL // RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-runtime=macosx-10.11 -fobjc-arc -emit-llvm -O2 -disable-llvm-passes -o - %s | FileCheck %s -check-prefix=ATTACHED-CALL @@ -7,7 +7,7 @@ // RUN: %clang_cc1 -triple i386-apple-darwin11 -fobjc-runtime=macosx-fragile-10.11 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-UNOPTIMIZED -check-prefix=CHECK-MARKED -check-prefix=CALL // Make sure it works on ARM64. -// RUN: %clang_cc1 -triple arm64-apple-ios9 -fobjc-runtime=ios-9.0 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-UNOPTIMIZED -check-prefix=CHECK-MARKED -check-prefix=CALL +// RUN: %clang_cc1 -triple arm64-apple-ios9 -fobjc-runtime=ios-9.0 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=X86-ATTACHED-CALL // Make sure it works on ARM. // RUN: %clang_cc1 -triple armv7-apple-ios9 -fobjc-runtime=ios-9.0 -fobjc-arc -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-UNOPTIMIZED -check-prefix=CHECK-MARKED -check-prefix=CALL @@ -36,14 +36,18 @@ void test_assign(void) { // CHECK-NEXT: ret void // DISABLED-LABEL: define{{.*}} void @test_assign() -// DISABLED: [[T0:%.*]] = call ptr @makeA() -// DISABLED-MARKED-NEXT: call void asm sideeffect -// DISABLED-NEXT: [[T2:%.*]] = {{.*}}call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) +// DISABLED: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// DISABLED-MARKED-NEXT: call void asm sideeffect "mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue", ""() +// DISABLED: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 // ATTACHED-CALL-LABEL: define{{.*}} void @test_assign() // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_assign() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_assign_assign(void) { __unsafe_unretained id x, y; x = y = makeA(); @@ -65,6 +69,10 @@ void test_assign_assign(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_assign_assign() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_strong_assign_assign(void) { __strong id x; __unsafe_unretained id y; @@ -91,6 +99,10 @@ void test_strong_assign_assign(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_strong_assign_assign() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_assign_strong_assign(void) { __unsafe_unretained id x; __strong id y; @@ -117,6 +129,10 @@ void test_assign_strong_assign(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_assign_strong_assign() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_init(void) { __unsafe_unretained id x = makeA(); } @@ -134,6 +150,10 @@ void test_init(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_init() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_init_assignment(void) { __unsafe_unretained id x; __unsafe_unretained id y = x = makeA(); @@ -155,6 +175,10 @@ void test_init_assignment(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_init_assignment() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_strong_init_assignment(void) { __unsafe_unretained id x; __strong id y = x = makeA(); @@ -178,6 +202,10 @@ void test_strong_init_assignment(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_strong_init_assignment() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_init_strong_assignment(void) { __strong id x; __unsafe_unretained id y = x = makeA(); @@ -203,6 +231,10 @@ void test_init_strong_assignment(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_init_strong_assignment() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_ignored(void) { makeA(); } @@ -217,6 +249,10 @@ void test_ignored(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_ignored() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + void test_cast_to_void(void) { (void) makeA(); } @@ -231,6 +267,10 @@ void test_cast_to_void(void) { // ATTACHED-CALL: [[T0:%.*]] = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ], // ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T0]]) +// X86-ATTACHED-CALL-LABEL: define{{.*}} void @test_cast_to_void() +// X86-ATTACHED-CALL: %call1 = call ptr @makeA() [ "clang.arc.attachedcall"(ptr @llvm.objc.unsafeClaimAutoreleasedReturnValue) ] +// X86-ATTACHED-CALL: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 + // This is always at the end of the module. diff --git a/clang/test/CodeGenObjC/arc-with-atthrow.m b/clang/test/CodeGenObjC/arc-with-atthrow.m index 19c3135ecf97f..3404e9edd6b9a 100644 --- a/clang/test/CodeGenObjC/arc-with-atthrow.m +++ b/clang/test/CodeGenObjC/arc-with-atthrow.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fobjc-exceptions -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -emit-llvm -fobjc-arc -fobjc-exceptions -o - %s | FileCheck %s // pr10411 id make(void); @@ -9,10 +9,10 @@ void test(void) { // TODO: We should probably emit this specific pattern without the reclaim. // CHECK-LABEL: define{{.*}} void @test() -// CHECK: [[T0:%.*]] = call ptr @make() -// CHECK-NEXT: [[T1:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) -// CHECK-NEXT: [[T2:%.*]] = call ptr @llvm.objc.autorelease(ptr [[T1]]) -// CHECK-NEXT: call void @objc_exception_throw(ptr [[T2]]) [[NR:#[0-9]+]] +// CHECK: %call1 = call ptr @make() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 +// CHECK: %0 = call ptr @llvm.objc.autorelease(ptr %call1) #2 +// CHECK: call void @objc_exception_throw(ptr %0) [[NR:#[0-9]+]] // CHECK-NEXT: unreachable // CHECK: attributes [[NR]] = { noreturn } diff --git a/clang/test/CodeGenObjC/ns_consume_null_check.m b/clang/test/CodeGenObjC/ns_consume_null_check.m index 8a730869d5184..d5d3c56aa472e 100644 --- a/clang/test/CodeGenObjC/ns_consume_null_check.m +++ b/clang/test/CodeGenObjC/ns_consume_null_check.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -fobjc-dispatch-method=mixed -fobjc-runtime-has-weak -fexceptions -fobjc-exceptions -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -emit-llvm -fobjc-arc -fobjc-dispatch-method=mixed -fobjc-runtime-has-weak -fexceptions -fobjc-exceptions -o - %s | FileCheck %s @interface NSObject - (id) new; @@ -83,10 +83,10 @@ void test2(id a) { } // CHECK-LABEL: define{{.*}} void @test2( -// CHECK: %[[CALL:.*]] = call ptr @objc_msgSend -// CHECK-NEXT: %[[V6:.*]] = {{.*}}call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL]]) +// CHECK: %call1 = call ptr @objc_msgSend(ptr noundef %0, ptr noundef %4, ptr noundef %2) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 -// CHECK: phi ptr [ %[[V6]], %{{.*}} ], [ null, %{{.*}} ] +// CHECK: phi ptr [ %call1, %{{.*}} ], [ null, %{{.*}} ] void test3(id a) { @try { @@ -96,9 +96,9 @@ void test3(id a) { } // CHECK-LABEL: define{{.*}} void @test3( -// CHECK: %[[CALL:.*]] = invoke ptr @objc_msgSend -// CHECK: %[[V6:.*]] = {{.*}}call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL]]) +// CHECK: %call1 = invoke ptr @objc_msgSend(ptr noundef %0, ptr noundef %4, ptr noundef %2) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 -// CHECK: phi ptr [ %[[V6]], %{{.*}} ], [ null, %{{.*}} ] +// CHECK: phi ptr [ %call1, %{{.*}} ], [ null, %{{.*}} ] // CHECK: attributes [[NUW]] = { nounwind } diff --git a/clang/test/CodeGenObjC/objc-arc-container-subscripting.m b/clang/test/CodeGenObjC/objc-arc-container-subscripting.m index 2f8f3f6cf690d..27bbeeef05e97 100644 --- a/clang/test/CodeGenObjC/objc-arc-container-subscripting.m +++ b/clang/test/CodeGenObjC/objc-arc-container-subscripting.m @@ -11,10 +11,10 @@ id func(void) { return array[3]; } -// CHECK: [[call:%.*]] = call ptr @objc_msgSend -// CHECK: [[SIX:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[call]]) [[NUW:#[0-9]+]] +// CHECK: %call1 = call ptr @objc_msgSend(ptr noundef %2, ptr noundef %3, i32 noundef 3) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 // CHECK: call void @llvm.objc.storeStrong(ptr {{%.*}}, ptr null) -// CHECK: [[EIGHT:%.*]] = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr [[SIX]]) [[NUW]] -// CHECK: ret ptr [[EIGHT]] +// CHECK: %4 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #2 +// CHECK: ret ptr %4 -// CHECK: attributes [[NUW]] = { nounwind } +// CHECK: attributes #2 = { nounwind } diff --git a/clang/test/CodeGenObjC/os_log.m b/clang/test/CodeGenObjC/os_log.m index 837883ec4bb75..e838beb248044 100644 --- a/clang/test/CodeGenObjC/os_log.m +++ b/clang/test/CodeGenObjC/os_log.m @@ -25,15 +25,15 @@ + (id)m1; // CHECK-O2: store ptr %[[V0]], ptr %[[A_ADDR]], align 8, // CHECK-O0: call void @llvm.objc.storeStrong(ptr %[[A_ADDR]], ptr %{{.*}}) // CHECK-O2: %[[V3:.*]] = call ptr @GenString() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] -// CHECK-O0: %[[CALL:.*]] = call ptr @GenString() -// CHECK-O0: %[[V3:.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL]]) -// CHECK: %[[V6:.*]] = call ptr @llvm.objc.retain(ptr %[[V3]]) +// CHECK-O0: %call1 = call ptr @GenString() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-O0: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: %[[V6:.*]] = call ptr @llvm.objc.retain(ptr %call1) // CHECK: store ptr %[[V6]], ptr %[[OS_LOG_ARG]], // CHECK: %[[V8:.*]] = ptrtoint ptr %[[V6]] to i64 // CHECK: %[[V9:.*]] = load ptr, ptr %[[A_ADDR]], align 8 // CHECK: %[[V10:.*]] = ptrtoint ptr %[[V9]] to i64 // CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(ptr noundef %{{.*}}, i64 noundef %[[V8]], i64 noundef %[[V10]]) -// CHECK: call void @llvm.objc.release(ptr %[[V3]]) +// CHECK: call void @llvm.objc.release(ptr %call1) // CHECK: call void @os_log_pack_send(ptr noundef %{{.*}}) // CHECK-O2: call void (...) @llvm.objc.clang.arc.use(ptr %[[V6]]) // CHECK-O2: %[[V13:.*]] = load ptr, ptr %[[OS_LOG_ARG]], align 8 @@ -64,13 +64,13 @@ void test_builtin_os_log2(void *buf, id __unsafe_unretained a) { // CHECK: alloca ptr, align 8 // CHECK: %[[OS_LOG_ARG:.*]] = alloca ptr, align 8 // CHECK-O2: %[[V2:.*]] = call ptr @GenString() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] -// CHECK-O0: %[[CALL:.*]] = call ptr @GenString() -// CHECK-O0: %[[V2:.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL]]) -// CHECK: %[[V5:.*]] = call ptr @llvm.objc.retain(ptr %[[V2]]) +// CHECK-O0: %call1 = call ptr @GenString() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-O0: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: %[[V5:.*]] = call ptr @llvm.objc.retain(ptr %call1) // CHECK: store ptr %[[V5]], ptr %[[OS_LOG_ARG]], align 8 // CHECK: %[[V6:.*]] = ptrtoint ptr %[[V5]] to i64 // CHECK: call void @__os_log_helper_1_2_1_8_64(ptr noundef %{{.*}}, i64 noundef %[[V6]]) -// CHECK: call void @llvm.objc.release(ptr %[[V2]]) +// CHECK: call void @llvm.objc.release(ptr %call1) // CHECK: call void @os_log_pack_send(ptr noundef %{{.*}}) // CHECK-O2: call void (...) @llvm.objc.clang.arc.use(ptr %[[V5]]) // CHECK-O2: %[[V9:.*]] = load ptr, ptr %[[OS_LOG_ARG]], align 8 @@ -87,20 +87,20 @@ void test_builtin_os_log3(void *buf) { // CHECK: %[[OS_LOG_ARG:.*]] = alloca ptr, align 8 // CHECK: %[[OS_LOG_ARG2:.*]] = alloca ptr, align 8 // CHECK-O2: %[[V4:.*]] = call {{.*}} @objc_msgSend{{.*}} [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] -// CHECK-O0: %[[CALL:.*]] = call {{.*}} @objc_msgSend -// CHECK-O0: %[[V4:.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL]]) -// CHECK: %[[V5:.*]] = call ptr @llvm.objc.retain(ptr %[[V4]]) +// CHECK-O0: %call1 = call {{.*}} @objc_msgSend{{.*}} [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-O0: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #1 +// CHECK: %[[V5:.*]] = call ptr @llvm.objc.retain(ptr %call1) // CHECK: store ptr %[[V5]], ptr %[[OS_LOG_ARG]], align 8 // CHECK: %[[V6:.*]] = ptrtoint ptr %[[V5]] to i64 // CHECK-O2: %[[V10:.*]] = call {{.*}} @objc_msgSend{{.*}} [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] -// CHECK-O0: %[[CALL1:.*]] = call {{.*}} @objc_msgSend -// CHECK-O0: %[[V10:.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[CALL1]]) -// CHECK: %[[V11:.*]] = call ptr @llvm.objc.retain(ptr %[[V10]]) +// CHECK-O0: %call2 = call {{.*}} @objc_msgSend{{.*}} [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK-O0: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call2) #1 +// CHECK: %[[V11:.*]] = call ptr @llvm.objc.retain(ptr %call2) // CHECK: store ptr %[[V11]], ptr %[[OS_LOG_ARG2]], align 8 // CHECK: %[[V12:.*]] = ptrtoint ptr %[[V11]] to i64 // CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(ptr noundef %{{.*}}, i64 noundef %[[V6]], i64 noundef %[[V12]]) -// CHECK: call void @llvm.objc.release(ptr %[[V10]]) -// CHECK: call void @llvm.objc.release(ptr %[[V4]]) +// CHECK: call void @llvm.objc.release(ptr %call2) +// CHECK: call void @llvm.objc.release(ptr %call1) // CHECK: call void @os_log_pack_send(ptr noundef %{{.*}}) // CHECK-O2: call void (...) @llvm.objc.clang.arc.use(ptr %[[V11]]) // CHECK-O2: %[[V14:.*]] = load ptr, ptr %[[OS_LOG_ARG2]], align 8 diff --git a/clang/test/CodeGenObjCXX/auto-release-result-assert.mm b/clang/test/CodeGenObjCXX/auto-release-result-assert.mm index f3d5f4d413f70..325845190a2a3 100644 --- a/clang/test/CodeGenObjCXX/auto-release-result-assert.mm +++ b/clang/test/CodeGenObjCXX/auto-release-result-assert.mm @@ -1,16 +1,22 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s // CHECK-LABEL: define{{.*}} ptr @_Z4foo1i( -// CHECK: %[[CALL:[a-z0-9]+]] = call noundef ptr @_Z4foo0i -// CHECK: ret ptr %[[CALL]] +// CHECK: %call1 = call noundef ptr @_Z4foo0i(i32 noundef %0) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #3 +// CHECK: %1 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #3 +// CHECK: ret ptr %1 // CHECK-LABEL: define{{.*}} ptr @_ZN2S22m1Ev( -// CHECK: %[[CALL:[a-z0-9]+]] = call noundef ptr @_Z4foo0i -// CHECK: ret ptr %[[CALL]] +// CHECK: %call2 = call noundef ptr @_Z4foo0i(i32 noundef 0) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call2) #3 +// CHECK: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call2) #3 +// CHECK: ret ptr %0 // CHECK-LABEL: define internal noundef ptr @Block1_block_invoke( -// CHECK: %[[CALL:[a-z0-9]+]] = call noundef ptr @_Z4foo0i -// CHECK: ret ptr %[[CALL]] +// CHECK: %call1 = call noundef ptr @_Z4foo0i(i32 noundef 0) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #3 +// CHECK: %0 = tail call ptr @llvm.objc.autoreleaseReturnValue(ptr %call1) #3 +// CHECK: ret ptr %0 struct S1; diff --git a/clang/test/CodeGenObjCXX/inheriting-constructor-cleanup.mm b/clang/test/CodeGenObjCXX/inheriting-constructor-cleanup.mm index 153e0a44334ba..69bf1fb8a73c7 100644 --- a/clang/test/CodeGenObjCXX/inheriting-constructor-cleanup.mm +++ b/clang/test/CodeGenObjCXX/inheriting-constructor-cleanup.mm @@ -21,8 +21,8 @@ void f() { Inheritor({g()}); } // CHECK-LABEL: define{{.*}} void @_Z1fv -// CHECK: %[[TMP:.*]] = call noundef ptr @_Z1gv() -// CHECK: {{.*}} = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr %[[TMP]]) +// CHECK: %call1 = call noundef ptr @_Z1gv() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] +// CHECK: call void (...) @llvm.objc.clang.arc.noop.use(ptr %call1) #2 // CHECK: call void (ptr, ptr, ...) @_ZN4BaseC2E6Strongz(ptr {{.*}}, ptr {{.*}}) // CHECK-NEXT: call void @_ZN9InheritorD1Ev(ptr {{.*}}) diff --git a/llvm/lib/Target/AArch64/AArch64FastISel.cpp b/llvm/lib/Target/AArch64/AArch64FastISel.cpp index cf344980cbaae..9bce0f19dd219 100644 --- a/llvm/lib/Target/AArch64/AArch64FastISel.cpp +++ b/llvm/lib/Target/AArch64/AArch64FastISel.cpp @@ -25,6 +25,7 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Analysis/BranchProbabilityInfo.h" +#include "llvm/Analysis/ObjCARCUtil.h" #include "llvm/CodeGen/CallingConvLower.h" #include "llvm/CodeGen/FastISel.h" #include "llvm/CodeGen/FunctionLoweringInfo.h" @@ -3159,6 +3160,10 @@ bool AArch64FastISel::fastLowerCall(CallLoweringInfo &CLI) { CLI.CB->getOperandBundle(LLVMContext::OB_kcfi)) return false; + // Allow SelectionDAG isel to handle clang.arc.attachedcall operand bundle. + if (CLI.CB && objcarc::hasAttachedCallOpBundle(CLI.CB)) + return false; + // Allow SelectionDAG isel to handle tail calls. if (IsTailCall) return false; diff --git a/llvm/lib/Target/X86/X86FastISel.cpp b/llvm/lib/Target/X86/X86FastISel.cpp index f007886115d35..465e4cf55227e 100644 --- a/llvm/lib/Target/X86/X86FastISel.cpp +++ b/llvm/lib/Target/X86/X86FastISel.cpp @@ -21,6 +21,7 @@ #include "X86Subtarget.h" #include "X86TargetMachine.h" #include "llvm/Analysis/BranchProbabilityInfo.h" +#include "llvm/Analysis/ObjCARCUtil.h" #include "llvm/CodeGen/FastISel.h" #include "llvm/CodeGen/FunctionLoweringInfo.h" #include "llvm/CodeGen/MachineConstantPool.h" @@ -3273,6 +3274,10 @@ bool X86FastISel::fastLowerCall(CallLoweringInfo &CLI) { if (CB && CB->isIndirectCall() && CB->getOperandBundle(LLVMContext::OB_kcfi)) return false; + // Allow SelectionDAG isel to handle clang.arc.attachedcall operand bundle. + if (CB && objcarc::hasAttachedCallOpBundle(CB)) + return false; + // Functions using thunks for indirect calls need to use SDISel. if (Subtarget->useIndirectThunkCalls()) return false; diff --git a/llvm/test/CodeGen/AArch64/call-rv-marker.ll b/llvm/test/CodeGen/AArch64/call-rv-marker.ll index 0bc64498da324..b9811b346175b 100644 --- a/llvm/test/CodeGen/AArch64/call-rv-marker.ll +++ b/llvm/test/CodeGen/AArch64/call-rv-marker.ll @@ -1,6 +1,7 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 4 ; RUN: llc -o - %s | FileCheck --check-prefix=SELDAG --check-prefix=CHECK %s ; RUN: llc -global-isel -o - %s | FileCheck --check-prefix=GISEL --check-prefix=CHECK %s +; RUN: llc -O0 -o - %s | FileCheck --check-prefix=O0 --check-prefix=CHECK %s target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target triple = "arm64-apple-ios" @@ -49,6 +50,18 @@ define dso_local ptr @rv_marker_1_retain() { ; GISEL-NEXT: bl _objc_retainAutoreleasedReturnValue ; GISEL-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload ; GISEL-NEXT: ret +; +; O0-LABEL: rv_marker_1_retain: +; O0: ; %bb.0: ; %entry +; O0-NEXT: stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 16 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: bl _foo1 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload +; O0-NEXT: ret entry: %call = call ptr @foo1() [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ] ret ptr %call @@ -78,6 +91,18 @@ define dso_local ptr @rv_marker_1_unsafeClaim() { ; GISEL-NEXT: bl _objc_unsafeClaimAutoreleasedReturnValue ; GISEL-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload ; GISEL-NEXT: ret +; +; O0-LABEL: rv_marker_1_unsafeClaim: +; O0: ; %bb.0: ; %entry +; O0-NEXT: stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 16 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: bl _foo1 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_unsafeClaimAutoreleasedReturnValue +; O0-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload +; O0-NEXT: ret entry: %call = call ptr @foo1() [ "clang.arc.attachedcall"(ptr @objc_unsafeClaimAutoreleasedReturnValue) ] ret ptr %call @@ -113,6 +138,21 @@ define dso_local void @rv_marker_2_select(i32 %c) { ; GISEL-NEXT: bl _objc_retainAutoreleasedReturnValue ; GISEL-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload ; GISEL-NEXT: b _foo2 +; +; O0-LABEL: rv_marker_2_select: +; O0: ; %bb.0: ; %entry +; O0-NEXT: stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 16 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: mov w8, #2 ; =0x2 +; O0-NEXT: subs w9, w0, #0 +; O0-NEXT: csinc w0, w8, wzr, eq +; O0-NEXT: bl _foo0 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload +; O0-NEXT: b _foo2 entry: %tobool.not = icmp eq i32 %c, 0 %.sink = select i1 %tobool.not, i32 2, i32 1 @@ -247,6 +287,68 @@ define dso_local void @rv_marker_3() personality ptr @__gxx_personality_v0 { ; GISEL-NEXT: .byte 0 ; On action: cleanup ; GISEL-NEXT: Lcst_end0: ; GISEL-NEXT: .p2align 2, 0x0 +; +; O0-LABEL: rv_marker_3: +; O0: Lfunc_begin0: +; O0-NEXT: .cfi_startproc +; O0-NEXT: .cfi_personality 155, ___gxx_personality_v0 +; O0-NEXT: .cfi_lsda 16, Lexception0 +; O0-NEXT: ; %bb.0: ; %entry +; O0-NEXT: sub sp, sp, #32 +; O0-NEXT: stp x29, x30, [sp, #16] ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 32 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: bl _foo1 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: str x0, [sp, #8] ; 8-byte Folded Spill +; O0-NEXT: Ltmp0: ; EH_LABEL +; O0-NEXT: bl _objc_object +; O0-NEXT: Ltmp1: ; EH_LABEL +; O0-NEXT: b LBB3_1 +; O0-NEXT: LBB3_1: ; %invoke.cont +; O0-NEXT: ldr x0, [sp, #8] ; 8-byte Folded Reload +; O0-NEXT: adrp x1, _objc_release@GOTPAGE +; O0-NEXT: ldr x1, [x1, _objc_release@GOTPAGEOFF] +; O0-NEXT: ldp x29, x30, [sp, #16] ; 16-byte Folded Reload +; O0-NEXT: add sp, sp, #32 +; O0-NEXT: br x1 +; O0-NEXT: LBB3_2: ; %lpad +; O0-NEXT: Ltmp2: ; EH_LABEL +; O0-NEXT: mov x1, x0 +; O0-NEXT: ldr x0, [sp, #8] ; 8-byte Folded Reload +; O0-NEXT: str x1, [sp] ; 8-byte Folded Spill +; O0-NEXT: adrp x8, _objc_release@GOTPAGE +; O0-NEXT: ldr x8, [x8, _objc_release@GOTPAGEOFF] +; O0-NEXT: blr x8 +; O0-NEXT: ldr x0, [sp] ; 8-byte Folded Reload +; O0-NEXT: bl __Unwind_Resume +; O0-NEXT: Lfunc_end0: +; O0-NEXT: .cfi_endproc +; O0-NEXT: .section __TEXT,__gcc_except_tab +; O0-NEXT: .p2align 2, 0x0 +; O0-NEXT: GCC_except_table3: +; O0-NEXT: Lexception0: +; O0-NEXT: .byte 255 ; @LPStart Encoding = omit +; O0-NEXT: .byte 255 ; @TType Encoding = omit +; O0-NEXT: .byte 1 ; Call site Encoding = uleb128 +; O0-NEXT: .uleb128 Lcst_end0-Lcst_begin0 +; O0-NEXT: Lcst_begin0: +; O0-NEXT: .uleb128 Lfunc_begin0-Lfunc_begin0 ; >> Call Site 1 << +; O0-NEXT: .uleb128 Ltmp0-Lfunc_begin0 ; Call between Lfunc_begin0 and Ltmp0 +; O0-NEXT: .byte 0 ; has no landing pad +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: .uleb128 Ltmp0-Lfunc_begin0 ; >> Call Site 2 << +; O0-NEXT: .uleb128 Ltmp1-Ltmp0 ; Call between Ltmp0 and Ltmp1 +; O0-NEXT: .uleb128 Ltmp2-Lfunc_begin0 ; jumps to Ltmp2 +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: .uleb128 Ltmp1-Lfunc_begin0 ; >> Call Site 3 << +; O0-NEXT: .uleb128 Lfunc_end0-Ltmp1 ; Call between Ltmp1 and Lfunc_end0 +; O0-NEXT: .byte 0 ; has no landing pad +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: Lcst_end0: +; O0-NEXT: .p2align 2, 0x0 entry: %call = call ptr @foo1() [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ] invoke void @objc_object(ptr %call) #5 @@ -419,6 +521,88 @@ define dso_local void @rv_marker_4() personality ptr @__gxx_personality_v0 { ; GISEL-NEXT: .byte 0 ; On action: cleanup ; GISEL-NEXT: Lcst_end1: ; GISEL-NEXT: .p2align 2, 0x0 +; +; O0-LABEL: rv_marker_4: +; O0: Lfunc_begin1: +; O0-NEXT: .cfi_startproc +; O0-NEXT: .cfi_personality 155, ___gxx_personality_v0 +; O0-NEXT: .cfi_lsda 16, Lexception1 +; O0-NEXT: ; %bb.0: ; %entry +; O0-NEXT: sub sp, sp, #64 +; O0-NEXT: stp x29, x30, [sp, #48] ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 64 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: Ltmp3: ; EH_LABEL +; O0-NEXT: bl _foo1 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: str x0, [sp, #32] ; 8-byte Folded Spill +; O0-NEXT: Ltmp4: ; EH_LABEL +; O0-NEXT: b LBB4_1 +; O0-NEXT: LBB4_1: ; %invoke.cont +; O0-NEXT: Ltmp6: ; EH_LABEL +; O0-NEXT: ldr x0, [sp, #32] ; 8-byte Folded Reload +; O0-NEXT: bl _objc_object +; O0-NEXT: Ltmp7: ; EH_LABEL +; O0-NEXT: b LBB4_2 +; O0-NEXT: LBB4_2: ; %invoke.cont2 +; O0-NEXT: ldr x0, [sp, #32] ; 8-byte Folded Reload +; O0-NEXT: adrp x8, _objc_release@GOTPAGE +; O0-NEXT: ldr x8, [x8, _objc_release@GOTPAGEOFF] +; O0-NEXT: blr x8 +; O0-NEXT: add x0, sp, #47 +; O0-NEXT: bl __ZN1SD1Ev +; O0-NEXT: ldp x29, x30, [sp, #48] ; 16-byte Folded Reload +; O0-NEXT: add sp, sp, #64 +; O0-NEXT: ret +; O0-NEXT: LBB4_3: ; %lpad +; O0-NEXT: Ltmp5: ; EH_LABEL +; O0-NEXT: str x0, [sp, #24] ; 8-byte Folded Spill +; O0-NEXT: b LBB4_5 +; O0-NEXT: LBB4_4: ; %lpad1 +; O0-NEXT: Ltmp8: ; EH_LABEL +; O0-NEXT: mov x1, x0 +; O0-NEXT: ldr x0, [sp, #32] ; 8-byte Folded Reload +; O0-NEXT: str x1, [sp, #16] ; 8-byte Folded Spill +; O0-NEXT: adrp x8, _objc_release@GOTPAGE +; O0-NEXT: ldr x8, [x8, _objc_release@GOTPAGEOFF] +; O0-NEXT: blr x8 +; O0-NEXT: ldr x0, [sp, #16] ; 8-byte Folded Reload +; O0-NEXT: str x0, [sp, #24] ; 8-byte Folded Spill +; O0-NEXT: b LBB4_5 +; O0-NEXT: LBB4_5: ; %ehcleanup +; O0-NEXT: ldr x8, [sp, #24] ; 8-byte Folded Reload +; O0-NEXT: str x8, [sp, #8] ; 8-byte Folded Spill +; O0-NEXT: add x0, sp, #47 +; O0-NEXT: bl __ZN1SD1Ev +; O0-NEXT: ldr x0, [sp, #8] ; 8-byte Folded Reload +; O0-NEXT: bl __Unwind_Resume +; O0-NEXT: Lfunc_end1: +; O0-NEXT: .cfi_endproc +; O0-NEXT: .section __TEXT,__gcc_except_tab +; O0-NEXT: .p2align 2, 0x0 +; O0-NEXT: GCC_except_table4: +; O0-NEXT: Lexception1: +; O0-NEXT: .byte 255 ; @LPStart Encoding = omit +; O0-NEXT: .byte 255 ; @TType Encoding = omit +; O0-NEXT: .byte 1 ; Call site Encoding = uleb128 +; O0-NEXT: .uleb128 Lcst_end1-Lcst_begin1 +; O0-NEXT: Lcst_begin1: +; O0-NEXT: .uleb128 Ltmp3-Lfunc_begin1 ; >> Call Site 1 << +; O0-NEXT: .uleb128 Ltmp4-Ltmp3 ; Call between Ltmp3 and Ltmp4 +; O0-NEXT: .uleb128 Ltmp5-Lfunc_begin1 ; jumps to Ltmp5 +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: .uleb128 Ltmp6-Lfunc_begin1 ; >> Call Site 2 << +; O0-NEXT: .uleb128 Ltmp7-Ltmp6 ; Call between Ltmp6 and Ltmp7 +; O0-NEXT: .uleb128 Ltmp8-Lfunc_begin1 ; jumps to Ltmp8 +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: .uleb128 Ltmp7-Lfunc_begin1 ; >> Call Site 3 << +; O0-NEXT: .uleb128 Lfunc_end1-Ltmp7 ; Call between Ltmp7 and Lfunc_end1 +; O0-NEXT: .byte 0 ; has no landing pad +; O0-NEXT: .byte 0 ; On action: cleanup +; O0-NEXT: Lcst_end1: +; O0-NEXT: .p2align 2, 0x0 entry: %s = alloca %struct.S, align 1 call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %s) #2 @@ -501,6 +685,25 @@ define dso_local ptr @rv_marker_5_indirect_call() { ; GISEL-NEXT: ldp x20, x19, [sp], #32 ; 16-byte Folded Reload ; GISEL-NEXT: ret ; GISEL-NEXT: .loh AdrpLdr Lloh8, Lloh9 +; +; O0-LABEL: rv_marker_5_indirect_call: +; O0: ; %bb.0: ; %entry +; O0-NEXT: sub sp, sp, #32 +; O0-NEXT: stp x29, x30, [sp, #16] ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 32 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: adrp x8, _fptr@PAGE +; O0-NEXT: ldr x8, [x8, _fptr@PAGEOFF] +; O0-NEXT: blr x8 +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: str x0, [sp, #8] ; 8-byte Folded Spill +; O0-NEXT: bl _foo2 +; O0-NEXT: ldr x0, [sp, #8] ; 8-byte Folded Reload +; O0-NEXT: ldp x29, x30, [sp, #16] ; 16-byte Folded Reload +; O0-NEXT: add sp, sp, #32 +; O0-NEXT: ret entry: %0 = load ptr, ptr @fptr, align 8 %call = call ptr %0() [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ] @@ -540,6 +743,23 @@ define dso_local void @rv_marker_multiarg(i64 %a, i64 %b, i64 %c) { ; GISEL-NEXT: bl _objc_retainAutoreleasedReturnValue ; GISEL-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload ; GISEL-NEXT: ret +; +; O0-LABEL: rv_marker_multiarg: +; O0: ; %bb.0: +; O0-NEXT: sub sp, sp, #32 +; O0-NEXT: stp x29, x30, [sp, #16] ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 32 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: str x0, [sp, #8] ; 8-byte Folded Spill +; O0-NEXT: mov x0, x2 +; O0-NEXT: ldr x2, [sp, #8] ; 8-byte Folded Reload +; O0-NEXT: bl _foo +; O0-NEXT: mov x29, x29 +; O0-NEXT: bl _objc_retainAutoreleasedReturnValue +; O0-NEXT: ldp x29, x30, [sp, #16] ; 16-byte Folded Reload +; O0-NEXT: add sp, sp, #32 +; O0-NEXT: ret call ptr @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ] ret void } @@ -566,6 +786,17 @@ define dso_local ptr @rv_marker_claim() { ; GISEL-NEXT: bl _objc_claimAutoreleasedReturnValue ; GISEL-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload ; GISEL-NEXT: ret +; +; O0-LABEL: rv_marker_claim: +; O0: ; %bb.0: ; %entry +; O0-NEXT: stp x29, x30, [sp, #-16]! ; 16-byte Folded Spill +; O0-NEXT: .cfi_def_cfa_offset 16 +; O0-NEXT: .cfi_offset w30, -8 +; O0-NEXT: .cfi_offset w29, -16 +; O0-NEXT: bl _foo1 +; O0-NEXT: bl _objc_claimAutoreleasedReturnValue +; O0-NEXT: ldp x29, x30, [sp], #16 ; 16-byte Folded Reload +; O0-NEXT: ret entry: %call = call ptr @foo1() [ "clang.arc.attachedcall"(ptr @objc_claimAutoreleasedReturnValue) ] ret ptr %call