Skip to content

Commit 78e1aad

Browse files
AZero13AZero13
committed
[ObjCARC] Delete empty autoreleasepools with no autoreleases in them
Erase empty autorelease pools that have no autorelease in them
1 parent d265105 commit 78e1aad

File tree

3 files changed

+289
-5
lines changed

3 files changed

+289
-5
lines changed

‎llvm/lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,8 @@ enum class ARCRuntimeEntryPointKind {
4646
UnsafeClaimRV,
4747
RetainAutorelease,
4848
RetainAutoreleaseRV,
49+
AutoreleasePoolPush,
50+
AutoreleasePoolPop,
4951
};
5052

5153
/// Declarations for ObjC runtime functions and constants. These are initialized
@@ -67,6 +69,8 @@ class ARCRuntimeEntryPoints {
6769
UnsafeClaimRV = nullptr;
6870
RetainAutorelease = nullptr;
6971
RetainAutoreleaseRV = nullptr;
72+
AutoreleasePoolPush = nullptr;
73+
AutoreleasePoolPop = nullptr;
7074
}
7175

7276
Function *get(ARCRuntimeEntryPointKind kind) {
@@ -101,6 +105,12 @@ class ARCRuntimeEntryPoints {
101105
case ARCRuntimeEntryPointKind::RetainAutoreleaseRV:
102106
return getIntrinsicEntryPoint(RetainAutoreleaseRV,
103107
Intrinsic::objc_retainAutoreleaseReturnValue);
108+
case ARCRuntimeEntryPointKind::AutoreleasePoolPush:
109+
return getIntrinsicEntryPoint(AutoreleasePoolPush,
110+
Intrinsic::objc_autoreleasePoolPush);
111+
case ARCRuntimeEntryPointKind::AutoreleasePoolPop:
112+
return getIntrinsicEntryPoint(AutoreleasePoolPop,
113+
Intrinsic::objc_autoreleasePoolPop);
104114
}
105115

106116
llvm_unreachable("Switch should be a covered switch.");
@@ -143,6 +153,12 @@ class ARCRuntimeEntryPoints {
143153
/// Declaration for objc_retainAutoreleaseReturnValue().
144154
Function *RetainAutoreleaseRV = nullptr;
145155

156+
/// Declaration for objc_autoreleasePoolPush().
157+
Function *AutoreleasePoolPush = nullptr;
158+
159+
/// Declaration for objc_autoreleasePoolPop().
160+
Function *AutoreleasePoolPop = nullptr;
161+
146162
Function *getIntrinsicEntryPoint(Function *&Decl, Intrinsic::ID IntID) {
147163
if (Decl)
148164
return Decl;

‎llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

Lines changed: 167 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@
3939
#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
4040
#include "llvm/Analysis/ObjCARCInstKind.h"
4141
#include "llvm/Analysis/ObjCARCUtil.h"
42+
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
4243
#include "llvm/IR/BasicBlock.h"
4344
#include "llvm/IR/CFG.h"
4445
#include "llvm/IR/Constant.h"
@@ -132,11 +133,8 @@ static const Value *FindSingleUseIdentifiedObject(const Value *Arg) {
132133
//
133134
// The second retain and autorelease can be deleted.
134135

135-
// TODO: It should be possible to delete
136-
// objc_autoreleasePoolPush and objc_autoreleasePoolPop
137-
// pairs if nothing is actually autoreleased between them. Also, autorelease
138-
// calls followed by objc_autoreleasePoolPop calls (perhaps in ObjC++ code
139-
// after inlining) can be turned into plain release calls.
136+
// TODO: Autorelease calls followed by objc_autoreleasePoolPop calls (perhaps in
137+
// ObjC++ code after inlining) can be turned into plain release calls.
140138

141139
// TODO: Critical-edge splitting. If the optimial insertion point is
142140
// a critical edge, the current algorithm has to fail, because it doesn't
@@ -566,6 +564,8 @@ class ObjCARCOpt {
566564

567565
void OptimizeReturns(Function &F);
568566

567+
void OptimizeAutoreleasePools(Function &F);
568+
569569
template <typename PredicateT>
570570
static void cloneOpBundlesIf(CallBase *CI,
571571
SmallVectorImpl<OperandBundleDef> &OpBundles,
@@ -2473,6 +2473,11 @@ bool ObjCARCOpt::run(Function &F, AAResults &AA) {
24732473
(1 << unsigned(ARCInstKind::AutoreleaseRV))))
24742474
OptimizeReturns(F);
24752475

2476+
// Optimizations for autorelease pools.
2477+
if (UsedInThisFunction & ((1 << unsigned(ARCInstKind::AutoreleasepoolPush)) |
2478+
(1 << unsigned(ARCInstKind::AutoreleasepoolPop))))
2479+
OptimizeAutoreleasePools(F);
2480+
24762481
// Gather statistics after optimization.
24772482
#ifndef NDEBUG
24782483
if (AreStatisticsEnabled()) {
@@ -2485,6 +2490,163 @@ bool ObjCARCOpt::run(Function &F, AAResults &AA) {
24852490
return Changed;
24862491
}
24872492

2493+
/// Helper function to recursively check if a value eventually leads to the
2494+
/// target instruction through pointer casts and uses, up to a specified depth.
2495+
static bool checkLeadsToTarget(Value *Val, User *Target, unsigned MaxDepth,
2496+
SmallPtrSet<Value *, 8> &Visited) {
2497+
if (MaxDepth == 0)
2498+
return false;
2499+
2500+
// Avoid infinite recursion by tracking visited values
2501+
if (!Visited.insert(Val).second)
2502+
return false;
2503+
2504+
for (User *U : Val->users()) {
2505+
if (U == Target)
2506+
return true;
2507+
2508+
// For pointer casts, recursively check their users
2509+
if (isa<CastInst>(U)) {
2510+
if (checkLeadsToTarget(U, Target, MaxDepth - 1, Visited)) {
2511+
return true;
2512+
}
2513+
}
2514+
}
2515+
2516+
return false;
2517+
}
2518+
2519+
/// Optimize autorelease pools by eliminating empty push/pop pairs.
2520+
void ObjCARCOpt::OptimizeAutoreleasePools(Function &F) {
2521+
LLVM_DEBUG(dbgs() << "\n== ObjCARCOpt::OptimizeAutoreleasePools ==\n");
2522+
2523+
OptimizationRemarkEmitter ORE(&F);
2524+
2525+
// Track empty autorelease pool push/pop pairs
2526+
SmallVector<std::pair<CallInst *, CallInst *>, 4> EmptyPoolPairs;
2527+
2528+
// Process each basic block independently.
2529+
// TODO: Can we optimize inter-block autorelease pool pairs?
2530+
// This would involve tracking autorelease pool state across blocks.
2531+
for (BasicBlock &BB : F) {
2532+
// Use a stack to track nested autorelease pools
2533+
SmallVector<std::pair<CallInst *, bool>, 4>
2534+
PoolStack; // {push_inst, has_autorelease_in_scope}
2535+
2536+
for (Instruction &Inst : BB) {
2537+
ARCInstKind Class = GetBasicARCInstKind(&Inst);
2538+
2539+
switch (Class) {
2540+
case ARCInstKind::AutoreleasepoolPush: {
2541+
// Start tracking a new autorelease pool scope
2542+
auto *Push = cast<CallInst>(&Inst);
2543+
PoolStack.push_back(
2544+
{Push, false}); // {push_inst, has_autorelease_in_scope}
2545+
LLVM_DEBUG(dbgs() << "Found autorelease pool push: " << *Push << "\n");
2546+
break;
2547+
}
2548+
2549+
case ARCInstKind::AutoreleasepoolPop: {
2550+
auto *Pop = cast<CallInst>(&Inst);
2551+
2552+
if (PoolStack.empty())
2553+
break;
2554+
2555+
auto &TopPool = PoolStack.back();
2556+
CallInst *PendingPush = TopPool.first;
2557+
bool HasAutoreleaseInScope = TopPool.second;
2558+
2559+
// Pop the stack - remove this pool scope
2560+
PoolStack.pop_back();
2561+
2562+
// Early exit if this pop doesn't match the pending push
2563+
if (Pop->getArgOperand(0)->stripPointerCasts() != PendingPush)
2564+
break;
2565+
2566+
// Early exit if there were autoreleases in this scope
2567+
if (HasAutoreleaseInScope)
2568+
break;
2569+
2570+
// Optimize: eliminate this empty autorelease pool pair
2571+
ORE.emit([&]() {
2572+
return OptimizationRemark(DEBUG_TYPE, "AutoreleasePoolElimination",
2573+
PendingPush)
2574+
<< "eliminated empty autorelease pool pair";
2575+
});
2576+
2577+
// Store the pair for careful deletion later
2578+
EmptyPoolPairs.push_back({PendingPush, Pop});
2579+
2580+
++NumNoops;
2581+
break;
2582+
}
2583+
case ARCInstKind::CallOrUser:
2584+
case ARCInstKind::Call:
2585+
case ARCInstKind::Autorelease:
2586+
case ARCInstKind::AutoreleaseRV:
2587+
case ARCInstKind::FusedRetainAutorelease:
2588+
case ARCInstKind::FusedRetainAutoreleaseRV:
2589+
case ARCInstKind::LoadWeak: {
2590+
// Track that we have autorelease calls in the current pool scope
2591+
if (!PoolStack.empty()) {
2592+
PoolStack.back().second = true; // Set has_autorelease_in_scope = true
2593+
LLVM_DEBUG(
2594+
dbgs()
2595+
<< "Found autorelease or potiential autorelease in pool scope: "
2596+
<< Inst << "\n");
2597+
}
2598+
break;
2599+
}
2600+
2601+
// Enumerate all remaining ARCInstKind cases explicitly
2602+
case ARCInstKind::Retain:
2603+
case ARCInstKind::RetainRV:
2604+
case ARCInstKind::UnsafeClaimRV:
2605+
case ARCInstKind::RetainBlock:
2606+
case ARCInstKind::Release:
2607+
case ARCInstKind::NoopCast:
2608+
case ARCInstKind::LoadWeakRetained:
2609+
case ARCInstKind::StoreWeak:
2610+
case ARCInstKind::InitWeak:
2611+
case ARCInstKind::MoveWeak:
2612+
case ARCInstKind::CopyWeak:
2613+
case ARCInstKind::DestroyWeak:
2614+
case ARCInstKind::StoreStrong:
2615+
case ARCInstKind::IntrinsicUser:
2616+
case ARCInstKind::User:
2617+
case ARCInstKind::None:
2618+
// These instruction kinds don't affect autorelease pool optimization
2619+
break;
2620+
}
2621+
}
2622+
}
2623+
2624+
// Handle empty pool pairs carefully to avoid use-after-delete
2625+
SmallVector<CallInst *, 8> DeadInsts;
2626+
for (auto &Pair : EmptyPoolPairs) {
2627+
CallInst *Push = Pair.first;
2628+
CallInst *Pop = Pair.second;
2629+
2630+
// Replace all uses of push with poison before deletion
2631+
Push->replaceAllUsesWith(PoisonValue::get(Push->getType()));
2632+
2633+
LLVM_DEBUG(dbgs() << "Erasing empty pool pair: " << *Push << " and " << *Pop
2634+
<< "\n");
2635+
DeadInsts.push_back(Pop);
2636+
DeadInsts.push_back(Push);
2637+
}
2638+
2639+
// Remove the pairs
2640+
if (!DeadInsts.empty()) {
2641+
Changed = true;
2642+
2643+
for (CallInst *DeadInst : DeadInsts) {
2644+
LLVM_DEBUG(dbgs() << "Erasing dead instruction: " << *DeadInst << "\n");
2645+
DeadInst->eraseFromParent();
2646+
}
2647+
}
2648+
}
2649+
24882650
/// @}
24892651
///
24902652

‎llvm/test/Transforms/ObjCARC/test_autorelease_pool.ll

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
2+
; Test for autorelease pool optimizations
3+
; RUN: opt -passes=objc-arc < %s -S | FileCheck %s
4+
5+
declare ptr @llvm.objc.autoreleasePoolPush()
6+
declare void @llvm.objc.autoreleasePoolPop(ptr)
7+
declare ptr @llvm.objc.autorelease(ptr)
8+
declare ptr @llvm.objc.retain(ptr)
9+
declare ptr @create_object()
10+
declare void @use_object(ptr)
11+
declare ptr @object_with_thing()
12+
declare void @opaque_callee()
13+
14+
; Test 1: Empty autorelease pool should be eliminated
15+
define void @test_empty_pool() {
16+
; CHECK-LABEL: define void @test_empty_pool() {
17+
; CHECK-NEXT: ret void
18+
;
19+
%pool = call ptr @llvm.objc.autoreleasePoolPush()
20+
call void @llvm.objc.autoreleasePoolPop(ptr %pool)
21+
ret void
22+
}
23+
24+
; Test 2: Pool with only release should be removed
25+
define void @test_autorelease_to_release() {
26+
; CHECK-LABEL: define void @test_autorelease_to_release() {
27+
; CHECK-NEXT: [[OBJ:%.*]] = call ptr @create_object()
28+
; CHECK-NEXT: call void @llvm.objc.release(ptr [[OBJ]]) #[[ATTR0:[0-9]+]], !clang.imprecise_release [[META0:![0-9]+]]
29+
; CHECK-NEXT: ret void
30+
;
31+
%obj = call ptr @create_object()
32+
%pool = call ptr @llvm.objc.autoreleasePoolPush()
33+
call ptr @llvm.objc.autorelease(ptr %obj)
34+
call void @llvm.objc.autoreleasePoolPop(ptr %pool)
35+
ret void
36+
}
37+
38+
; Test 3: Pool with autoreleases should not be optimized
39+
define void @test_multiple_autoreleases() {
40+
; CHECK-LABEL: define void @test_multiple_autoreleases() {
41+
; CHECK-NEXT: [[OBJ1:%.*]] = call ptr @create_object()
42+
; CHECK-NEXT: [[OBJ2:%.*]] = call ptr @create_object()
43+
; CHECK-NEXT: [[POOL:%.*]] = call ptr @llvm.objc.autoreleasePoolPush() #[[ATTR0]]
44+
; CHECK-NEXT: call void @use_object(ptr [[OBJ1]])
45+
; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.objc.autorelease(ptr [[OBJ1]]) #[[ATTR0]]
46+
; CHECK-NEXT: call void @use_object(ptr [[OBJ2]])
47+
; CHECK-NEXT: [[TMP2:%.*]] = call ptr @llvm.objc.autorelease(ptr [[OBJ2]]) #[[ATTR0]]
48+
; CHECK-NEXT: call void @llvm.objc.autoreleasePoolPop(ptr [[POOL]]) #[[ATTR0]]
49+
; CHECK-NEXT: ret void
50+
;
51+
%obj1 = call ptr @create_object()
52+
%obj2 = call ptr @create_object()
53+
%pool = call ptr @llvm.objc.autoreleasePoolPush()
54+
call void @use_object(ptr %obj1)
55+
call ptr @llvm.objc.autorelease(ptr %obj1)
56+
call void @use_object(ptr %obj2)
57+
call ptr @llvm.objc.autorelease(ptr %obj2)
58+
call void @llvm.objc.autoreleasePoolPop(ptr %pool)
59+
ret void
60+
}
61+
62+
; Test 4: Pool with calls should not be optimized
63+
define void @test_calls() {
64+
; CHECK-LABEL: define void @test_calls() {
65+
; CHECK-NEXT: [[POOL:%.*]] = call ptr @llvm.objc.autoreleasePoolPush() #[[ATTR0]]
66+
; CHECK-NEXT: [[OBJ1:%.*]] = call ptr @object_with_thing()
67+
; CHECK-NEXT: call void @use_object(ptr [[OBJ1]])
68+
; CHECK-NEXT: call void @llvm.objc.autoreleasePoolPop(ptr [[POOL]]) #[[ATTR0]]
69+
; CHECK-NEXT: ret void
70+
;
71+
%pool = call ptr @llvm.objc.autoreleasePoolPush()
72+
%obj1 = call ptr @object_with_thing()
73+
call void @use_object(ptr %obj1)
74+
call void @llvm.objc.autoreleasePoolPop(ptr %pool)
75+
ret void
76+
}
77+
78+
; Test 5: Pool with opaque call should not be optimized
79+
define void @test_opaque_call() {
80+
; CHECK-LABEL: define void @test_opaque_call() {
81+
; CHECK-NEXT: [[POOL:%.*]] = call ptr @llvm.objc.autoreleasePoolPush() #[[ATTR0]]
82+
; CHECK-NEXT: call void @opaque_callee()
83+
; CHECK-NEXT: call void @llvm.objc.autoreleasePoolPop(ptr [[POOL]]) #[[ATTR0]]
84+
; CHECK-NEXT: ret void
85+
;
86+
%pool = call ptr @llvm.objc.autoreleasePoolPush()
87+
call void @opaque_callee()
88+
call void @llvm.objc.autoreleasePoolPop(ptr %pool)
89+
ret void
90+
}
91+
92+
; Test 6: Nested empty pools should be eliminated
93+
define void @test_nested_empty_pools() {
94+
; CHECK-LABEL: define void @test_nested_empty_pools() {
95+
; CHECK-NEXT: ret void
96+
;
97+
%pool1 = call ptr @llvm.objc.autoreleasePoolPush()
98+
%pool2 = call ptr @llvm.objc.autoreleasePoolPush()
99+
call void @llvm.objc.autoreleasePoolPop(ptr %pool2)
100+
call void @llvm.objc.autoreleasePoolPop(ptr %pool1)
101+
ret void
102+
}
103+
104+
;.
105+
; CHECK: [[META0]] = !{}
106+
;.

0 commit comments

Comments
 (0)