[llvm] [ObjCARC] Optimize loadWeak across copyWeak and moveWeak (PR #218417)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 24 07:01:21 PDT 2026
https://github.com/AZero13 created https://github.com/llvm/llvm-project/pull/218417
Previously, the backward scan for redundant weak loads maintained its tracked pointer locally within the instruction-visitation loop. If it encountered a CopyWeak or MoveWeak operating on the tracked pointer, it conservatively aborted the scan (goto clobbered).
>From e1f68f3b254e6108a37116c48e7c2cd3c6a6e86e Mon Sep 17 00:00:00 2001
From: AZero13 <gfunni234 at gmail.com>
Date: Mon, 24 Aug 2026 09:56:17 -0400
Subject: [PATCH 1/2] Precommit test
---
llvm/test/Transforms/ObjCARC/weak.ll | 66 ++++++++++++++++++++++++++++
1 file changed, 66 insertions(+)
diff --git a/llvm/test/Transforms/ObjCARC/weak.ll b/llvm/test/Transforms/ObjCARC/weak.ll
index db63847c8f6c9..bf9b55d736d32 100644
--- a/llvm/test/Transforms/ObjCARC/weak.ll
+++ b/llvm/test/Transforms/ObjCARC/weak.ll
@@ -58,3 +58,69 @@ entry:
ret void
}
+
+declare void @use_pointer(ptr)
+
+; Test that copyWeak enables eliminating a redundant loadWeak.
+define void @test_copyweak(ptr %src, ptr %dest, ptr %val) {
+; CHECK-LABEL: @test_copyweak(
+; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
+; CHECK-NEXT: call void @llvm.objc.copyWeak(ptr [[DEST:%.*]], ptr [[SRC]])
+; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[DEST]])
+; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: ret void
+;
+ call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
+ call void @llvm.objc.copyWeak(ptr %dest, ptr %src)
+ %x = call ptr @llvm.objc.loadWeak(ptr %dest)
+ call void @use_pointer(ptr %x)
+ ret void
+}
+
+; Test that moveWeak enables eliminating a redundant loadWeak.
+define void @test_moveweak(ptr %src, ptr %dest, ptr %val) {
+; CHECK-LABEL: @test_moveweak(
+; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
+; CHECK-NEXT: call void @llvm.objc.moveWeak(ptr [[DEST:%.*]], ptr [[SRC]])
+; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[DEST]])
+; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: ret void
+;
+ call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
+ call void @llvm.objc.moveWeak(ptr %dest, ptr %src)
+ %x = call ptr @llvm.objc.loadWeak(ptr %dest)
+ call void @use_pointer(ptr %x)
+ ret void
+}
+
+; Test that moveWeak clobbers a load from its source.
+define void @test_moveweak_clobber(ptr %src, ptr %dest, ptr %val) {
+; CHECK-LABEL: @test_moveweak_clobber(
+; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
+; CHECK-NEXT: call void @llvm.objc.moveWeak(ptr [[DEST:%.*]], ptr [[SRC]])
+; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[SRC]])
+; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: ret void
+;
+ call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
+ call void @llvm.objc.moveWeak(ptr %dest, ptr %src)
+ %x = call ptr @llvm.objc.loadWeak(ptr %src)
+ call void @use_pointer(ptr %x)
+ ret void
+}
+
+; Test that copyWeak does NOT clobber a load from its source.
+define void @test_copyweak_no_clobber(ptr %src, ptr %dest, ptr %val) {
+; CHECK-LABEL: @test_copyweak_no_clobber(
+; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
+; CHECK-NEXT: call void @llvm.objc.copyWeak(ptr [[DEST:%.*]], ptr [[SRC]])
+; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[SRC]])
+; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: ret void
+;
+ call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
+ call void @llvm.objc.copyWeak(ptr %dest, ptr %src)
+ %x = call ptr @llvm.objc.loadWeak(ptr %src)
+ call void @use_pointer(ptr %x)
+ ret void
+}
>From eca6333daf5441881e58dfdb09854509cc87cbb9 Mon Sep 17 00:00:00 2001
From: AZero13 <gfunni234 at gmail.com>
Date: Mon, 24 Aug 2026 10:00:01 -0400
Subject: [PATCH 2/2] [ObjCARC] Optimize loadWeak across copyWeak and moveWeak
Previously, the backward scan for redundant weak loads maintained its tracked pointer locally within the instruction-visitation loop. If it encountered a CopyWeak or MoveWeak operating on the tracked pointer, it conservatively aborted the scan (goto clobbered).
---
llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp | 25 ++++++++++++++++-----
llvm/test/Transforms/ObjCARC/weak.ll | 6 ++---
2 files changed, 22 insertions(+), 9 deletions(-)
diff --git a/llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp b/llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
index f92e5bbdf0111..c62283605f03d 100644
--- a/llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
+++ b/llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
@@ -2096,6 +2096,7 @@ void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
// within the same block. Theoretically, we could do memdep-style non-local
// analysis too, but that would want caching. A better approach would be to
// use the technique that EarlyCSE uses.
+ Value *Arg = cast<CallInst>(Inst)->getArgOperand(0);
inst_iterator Current = std::prev(I);
BasicBlock *CurrentBB = &*Current.getBasicBlockIterator();
for (BasicBlock::iterator B = CurrentBB->begin(),
@@ -2110,7 +2111,6 @@ void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
// with that one.
CallInst *Call = cast<CallInst>(Inst);
CallInst *EarlierCall = cast<CallInst>(EarlierInst);
- Value *Arg = Call->getArgOperand(0);
Value *EarlierArg = EarlierCall->getArgOperand(0);
switch (PA.getAA()->alias(Arg, EarlierArg)) {
case AliasResult::MustAlias:
@@ -2140,7 +2140,6 @@ void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
// replace this load's value with the stored value.
CallInst *Call = cast<CallInst>(Inst);
CallInst *EarlierCall = cast<CallInst>(EarlierInst);
- Value *Arg = Call->getArgOperand(0);
Value *EarlierArg = EarlierCall->getArgOperand(0);
switch (PA.getAA()->alias(Arg, EarlierArg)) {
case AliasResult::MustAlias:
@@ -2165,9 +2164,25 @@ void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
break;
}
case ARCInstKind::MoveWeak:
- case ARCInstKind::CopyWeak:
- // TOOD: Grab the copied value.
- goto clobbered;
+ case ARCInstKind::CopyWeak: {
+ CallInst *EarlierCall = cast<CallInst>(EarlierInst);
+ Value *EarlierDest = EarlierCall->getArgOperand(0);
+ Value *EarlierSrc = EarlierCall->getArgOperand(1);
+ switch (PA.getAA()->alias(Arg, EarlierDest)) {
+ case AliasResult::MustAlias:
+ Arg = EarlierSrc;
+ break;
+ case AliasResult::MayAlias:
+ case AliasResult::PartialAlias:
+ goto clobbered;
+ case AliasResult::NoAlias:
+ if (EarlierClass == ARCInstKind::MoveWeak &&
+ PA.getAA()->alias(Arg, EarlierSrc) != AliasResult::NoAlias)
+ goto clobbered;
+ break;
+ }
+ break;
+ }
case ARCInstKind::AutoreleasepoolPush:
case ARCInstKind::None:
case ARCInstKind::IntrinsicUser:
diff --git a/llvm/test/Transforms/ObjCARC/weak.ll b/llvm/test/Transforms/ObjCARC/weak.ll
index bf9b55d736d32..3339ca79bd5ac 100644
--- a/llvm/test/Transforms/ObjCARC/weak.ll
+++ b/llvm/test/Transforms/ObjCARC/weak.ll
@@ -66,8 +66,7 @@ define void @test_copyweak(ptr %src, ptr %dest, ptr %val) {
; CHECK-LABEL: @test_copyweak(
; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
; CHECK-NEXT: call void @llvm.objc.copyWeak(ptr [[DEST:%.*]], ptr [[SRC]])
-; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[DEST]])
-; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: call void @use_pointer(ptr [[VAL]])
; CHECK-NEXT: ret void
;
call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
@@ -82,8 +81,7 @@ define void @test_moveweak(ptr %src, ptr %dest, ptr %val) {
; CHECK-LABEL: @test_moveweak(
; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.storeWeak(ptr [[SRC:%.*]], ptr [[VAL:%.*]])
; CHECK-NEXT: call void @llvm.objc.moveWeak(ptr [[DEST:%.*]], ptr [[SRC]])
-; CHECK-NEXT: [[X:%.*]] = call ptr @llvm.objc.loadWeak(ptr [[DEST]])
-; CHECK-NEXT: call void @use_pointer(ptr [[X]])
+; CHECK-NEXT: call void @use_pointer(ptr [[VAL]])
; CHECK-NEXT: ret void
;
call ptr @llvm.objc.storeWeak(ptr %src, ptr %val)
More information about the llvm-commits
mailing list