llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-backend-aarch64 @llvm/pr-subscribers-clang-codegen Author: John Hui (j-hui) <details> <summary>Changes</summary> This reverts commit 4b939beb79e3390046b760bef71b7d891ba9b4df. This commit seems to be causing these test failures: - ThreadSanitizer-x86_64-iossim.Darwin.norace-objcxx-run-time.mm https://ci.swift.org/job/llvm.org/job/clang-san-iossim/14230/testReport/junit/ThreadSanitizer-x86_64-iossim/Darwin/norace_objcxx_run_time_mm/ - ThreadSanitizer-x86_64-iossim.Darwin.objc-synchronize-cycle-tagged.mm https://ci.swift.org/job/llvm.org/job/clang-san-iossim/14230/testReport/junit/ThreadSanitizer-x86_64-iossim/Darwin/objc_synchronize_cycle_tagged_mm/ - ThreadSanitizer-x86_64-iossim.Darwin.objc-synchronize-tagged.mm https://ci.swift.org/job/llvm.org/job/clang-san-iossim/14230/testReport/junit/ThreadSanitizer-x86_64-iossim/Darwin/objc_synchronize_tagged_mm/ - ThreadSanitizer-x86_64-iossim.Darwin.objc-synchronize.mm https://ci.swift.org/job/llvm.org/job/clang-san-iossim/14230/testReport/junit/ThreadSanitizer-x86_64-iossim/Darwin/objc_synchronize_mm/ With the error message: ``` fatal error: error in backend: Cannot select: intrinsic %llvm.objc.clang.arc.noop.use ``` --- Patch is 56.67 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/177533.diff 16 Files Affected: - (modified) clang/lib/CodeGen/CGObjC.cpp (+7-4) - (modified) clang/test/CodeGenObjC/arc-arm.m (+1-22) - (modified) clang/test/CodeGenObjC/arc-foreach.m (+93-93) - (modified) clang/test/CodeGenObjC/arc-property.m (+3-3) - (modified) clang/test/CodeGenObjC/arc-related-result-type.m (+3-3) - (modified) clang/test/CodeGenObjC/arc-unopt.m (+5-9) - (modified) clang/test/CodeGenObjC/arc-unsafeclaim.m (+5-45) - (modified) clang/test/CodeGenObjC/arc-with-atthrow.m (+5-5) - (modified) clang/test/CodeGenObjC/ns_consume_null_check.m (+7-7) - (modified) clang/test/CodeGenObjC/objc-arc-container-subscripting.m (+5-5) - (modified) clang/test/CodeGenObjC/os_log.m (+16-16) - (modified) clang/test/CodeGenObjCXX/auto-release-result-assert.mm (+6-12) - (modified) clang/test/CodeGenObjCXX/inheriting-constructor-cleanup.mm (+2-2) - (modified) llvm/lib/Target/AArch64/AArch64FastISel.cpp (-5) - (modified) llvm/lib/Target/X86/X86FastISel.cpp (-5) - (modified) llvm/test/CodeGen/AArch64/call-rv-marker.ll (+1-232) ``````````diff diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp index 3d4a6fb1ac36f..10aad2e26938d 100644 --- a/clang/lib/CodeGen/CGObjC.cpp +++ b/clang/lib/CodeGen/CGObjC.cpp @@ -2415,7 +2415,9 @@ 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. + // 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. ObjCEntrypoints &EPs = CGF.CGM.getObjCEntrypoints(); llvm::Function *&EP = IsRetainRV ? EPs.objc_retainAutoreleasedReturnValue @@ -2427,10 +2429,11 @@ static llvm::Value *emitOptimizedARCReturnCall(llvm::Value *value, llvm::Triple::ArchType Arch = CGF.CGM.getTriple().getArch(); - // FIXME: Do this on all targets. This can be enabled only if + // 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 (Arch == llvm::Triple::x86_64 || - (Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32)) { + if (CGF.CGM.getCodeGenOpts().OptimizationLevel > 0 && + (Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32 || + Arch == llvm::Triple::x86_64)) { llvm::Value *bundleArgs[] = {EP}; llvm::OperandBundleDef OB("clang.arc.attachedcall", bundleArgs); auto *oldCall = cast<llvm::CallBase>(value); diff --git a/clang/test/CodeGenObjC/arc-arm.m b/clang/test/CodeGenObjC/arc-arm.m index ed2ff7e51f047..6105644c2d684 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 -check-prefix=ARM64-ATTACHED +// RUN: %clang_cc1 -triple arm64-apple-ios -emit-llvm -fblocks -fobjc-arc -o - %s | FileCheck %s // use an autorelease marker on ARM64. @@ -7,11 +7,6 @@ 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(); } @@ -23,12 +18,6 @@ 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(); } @@ -37,11 +26,6 @@ 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(); } @@ -49,10 +33,5 @@ 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 557e75879e4c0..35620fce20485 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-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-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-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-ATTACHED-NEXT: store ptr null, ptr [[ARRAY]] -// CHECK-LP64-ATTACHED-NEXT: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr {{%.*}}) [[NUW:#[0-9]+]] +// CHECK-LP64-NEXT: store ptr null, ptr [[ARRAY]] +// CHECK-LP64-NEXT: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr {{%.*}}) [[NUW:#[0-9]+]] // Initialize the fast enumaration state. -// CHECK-LP64-ATTACHED-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[STATE]], i8 0, i64 64, i1 false) +// CHECK-LP64-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-ATTACHED-NEXT: [[T0:%.*]] = load ptr, ptr [[ARRAY]], align 8 -// CHECK-LP64-ATTACHED-NEXT: [[SAVED_ARRAY:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]]) +// CHECK-LP64-NEXT: [[T0:%.*]] = load ptr, ptr [[ARRAY]], align 8 +// CHECK-LP64-NEXT: [[SAVED_ARRAY:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]]) // Call the enumeration method. -// 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-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 for a nonzero result. -// 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-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-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-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) +// 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) // Release the array. -// CHECK-LP64-ATTACHED: call void @llvm.objc.release(ptr [[SAVED_ARRAY]]) +// CHECK-LP64: call void @llvm.objc.release(ptr [[SAVED_ARRAY]]) // Destroy 'array'. -// CHECK-LP64-ATTACHED: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr null) -// CHECK-LP64-ATTACHED-NEXT: ret void +// CHECK-LP64: call void @llvm.objc.storeStrong(ptr [[ARRAY]], ptr null) +// CHECK-LP64-NEXT: ret void -// 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]]) +// 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]]) void test1(NSArray *array) { for (__weak id x in array) { @@ -91,24 +91,24 @@ void test1(NSArray *array) { } } -// 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]]) +// 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]]) @interface Test2 - (NSArray *) array; @@ -120,19 +120,19 @@ void test2(Test2 *a) { } // CHECK-LP64-LABEL: define{{.*}} void @test2( -// 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 +// CHECK-LP64: [[T0:%.*]] = call ptr @objc_msgSend( +// CHECK-LP64-NEXT: [[T2:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) // 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-ATTACHED: @objc_enumerationMutation +// CHECK-LP64: @objc_enumerationMutation -// CHECK-LP64-ATTACHED: load ptr, ptr @OBJC_SELECTOR_REFERENCES_ -// CHECK-LP64-ATTACHED-NEXT: @objc_msgSend +// CHECK-LP64: load ptr, ptr @OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-NEXT: @objc_msgSend -// CHECK-LP64-ATTACHED: call void @llvm.objc.release(ptr [[T2]]) +// CHECK-LP64: 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-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]] + // 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]] } @interface NSObject @end @@ -178,36 +178,36 @@ - (void) foo2 { } @end -// 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-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-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-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: 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-OPT: [[T5:%.*]] = load ptr, ptr [[T0]] // CHECK-LP64-OPT: call void (...) @llvm.objc.clang.arc.use(ptr [[T5]]) -// CHECK-LP64-ATTACHED: {{^|:}}[[CLEANUP_CONT]] -// CHECK-LP64-ATTACHED-NEXT: br label %[[FORCOLL_END]] +// CHECK-LP64: {{^|:}}[[CLEANUP_CONT]] +// CHECK-LP64-NEXT: br label %[[FORCOLL_END]] -// CHECK-LP64-ATTACHED: {{^|:}}[[FORCOLL_END]] -// CHECK-LP64-ATTACHED-NEXT: ret void +// CHECK-LP64: {{^|:}}[[FORCOLL_END]] +// CHECK-LP64-NEXT: ret void -// CHECK-LP64-ATTACHED: {{^|:}}[[UNREACHABLE]] -// CHECK-LP64-ATTACHED-NEXT: unreachable +// CHECK-LP64: {{^|:}}[[UNREACHABLE]] +// CHECK-LP64-NEXT: unreachable -// CHECK-LP64-ATTACHED: attributes [[NUW]] = { nounwind } +// CHECK-LP64: attributes [[NUW]] = { nounwind } diff --git a/clang/test/CodeGenObjC/arc-property.m b/clang/test/CodeGenObjC/arc-property.m index 42e838042ef7f..3209993cc6d32 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: %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 +// CHECK: [[T0:%.*]] = call ptr @test3_helper() +// CHECK-NEXT: [[T1:%.*]] = notail call ptr @llvm.objc.retainAutoreleasedReturnValue(ptr [[T0]]) +// CHECK-NEXT: ret ptr [[T1]] - (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 83d3cc89bc2b1..3bb3dfb60636f 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: %call1 = call ptr @objc_msgSend(ptr noundef %0, ptr noundef %1) [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ] -// C... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/177533 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
