[clang] [llvm] Revert "Reapply "[CGObjC] Allow clang.arc.attachedcall on -O0 (#164875)" (#177285)" (PR #177533)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Jan 22 22:20:45 PST 2026
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
More information about the cfe-commits
mailing list