Skip to content

[CGObjC] Allow clang.arc.attachedcall on -O0 #164875

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

[CGObjC] Allow clang.arc.attachedcall on -O0 #164875

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 3 additions & 8 deletions clang/lib/CodeGen/CGObjC.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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<llvm::CallBase>(value);
Expand Down
23 changes: 22 additions & 1 deletion clang/test/CodeGenObjC/arc-arm.m
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,17 @@
// 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.

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();
}

Expand All @@ -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();
}

Expand All @@ -26,12 +37,22 @@ 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();
}

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();
}
186 changes: 93 additions & 93 deletions clang/test/CodeGenObjC/arc-foreach.m
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,95 +20,95 @@ 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
// CHECK-LP64-OPT-NEXT: [[BUFFER:%.*]] = alloca [16 x ptr], align 8
// 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) {
use_block(^{ use(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]])
// 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;
Expand All @@ -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
Expand All @@ -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
Expand All @@ -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 }
6 changes: 3 additions & 3 deletions clang/test/CodeGenObjC/arc-property.m
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down
6 changes: 3 additions & 3 deletions clang/test/CodeGenObjC/arc-related-result-type.m
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Loading
Loading