1 //===- ObjCARCAPElim.cpp - ObjC ARC Optimization --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 ///
11 /// This file defines ObjC ARC optimizations. ARC stands for Automatic
12 /// Reference Counting and is a system for managing reference counts for objects
13 /// in Objective C.
14 ///
15 /// This specific file implements optimizations which remove extraneous
16 /// autorelease pools.
17 ///
18 /// WARNING: This file knows about certain library functions. It recognizes them
19 /// by name, and hardwires knowledge of their semantics.
20 ///
21 /// WARNING: This file knows about how certain Objective-C library functions are
22 /// used. Naive LLVM IR transformations which would otherwise be
23 /// behavior-preserving may break these assumptions.
24 ///
25 //===----------------------------------------------------------------------===//
26
27 #define DEBUG_TYPE "objc-arc-ap-elim"
28 #include "ObjCARC.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/IR/Constants.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/raw_ostream.h"
33
34 using namespace llvm;
35 using namespace llvm::objcarc;
36
37 namespace {
38 /// \brief Autorelease pool elimination.
39 class ObjCARCAPElim : public ModulePass {
40 virtual void getAnalysisUsage(AnalysisUsage &AU) const;
41 virtual bool runOnModule(Module &M);
42
43 static bool MayAutorelease(ImmutableCallSite CS, unsigned Depth = 0);
44 static bool OptimizeBB(BasicBlock *BB);
45
46 public:
47 static char ID;
ObjCARCAPElim()48 ObjCARCAPElim() : ModulePass(ID) {
49 initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry());
50 }
51 };
52 }
53
54 char ObjCARCAPElim::ID = 0;
55 INITIALIZE_PASS(ObjCARCAPElim,
56 "objc-arc-apelim",
57 "ObjC ARC autorelease pool elimination",
58 false, false)
59
createObjCARCAPElimPass()60 Pass *llvm::createObjCARCAPElimPass() {
61 return new ObjCARCAPElim();
62 }
63
getAnalysisUsage(AnalysisUsage & AU) const64 void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const {
65 AU.setPreservesCFG();
66 }
67
68 /// Interprocedurally determine if calls made by the given call site can
69 /// possibly produce autoreleases.
MayAutorelease(ImmutableCallSite CS,unsigned Depth)70 bool ObjCARCAPElim::MayAutorelease(ImmutableCallSite CS, unsigned Depth) {
71 if (const Function *Callee = CS.getCalledFunction()) {
72 if (Callee->isDeclaration() || Callee->mayBeOverridden())
73 return true;
74 for (Function::const_iterator I = Callee->begin(), E = Callee->end();
75 I != E; ++I) {
76 const BasicBlock *BB = I;
77 for (BasicBlock::const_iterator J = BB->begin(), F = BB->end();
78 J != F; ++J)
79 if (ImmutableCallSite JCS = ImmutableCallSite(J))
80 // This recursion depth limit is arbitrary. It's just great
81 // enough to cover known interesting testcases.
82 if (Depth < 3 &&
83 !JCS.onlyReadsMemory() &&
84 MayAutorelease(JCS, Depth + 1))
85 return true;
86 }
87 return false;
88 }
89
90 return true;
91 }
92
OptimizeBB(BasicBlock * BB)93 bool ObjCARCAPElim::OptimizeBB(BasicBlock *BB) {
94 bool Changed = false;
95
96 Instruction *Push = 0;
97 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
98 Instruction *Inst = I++;
99 switch (GetBasicInstructionClass(Inst)) {
100 case IC_AutoreleasepoolPush:
101 Push = Inst;
102 break;
103 case IC_AutoreleasepoolPop:
104 // If this pop matches a push and nothing in between can autorelease,
105 // zap the pair.
106 if (Push && cast<CallInst>(Inst)->getArgOperand(0) == Push) {
107 Changed = true;
108 DEBUG(dbgs() << "ObjCARCAPElim::OptimizeBB: Zapping push pop "
109 "autorelease pair:\n"
110 " Pop: " << *Inst << "\n"
111 << " Push: " << *Push << "\n");
112 Inst->eraseFromParent();
113 Push->eraseFromParent();
114 }
115 Push = 0;
116 break;
117 case IC_CallOrUser:
118 if (MayAutorelease(ImmutableCallSite(Inst)))
119 Push = 0;
120 break;
121 default:
122 break;
123 }
124 }
125
126 return Changed;
127 }
128
runOnModule(Module & M)129 bool ObjCARCAPElim::runOnModule(Module &M) {
130 if (!EnableARCOpts)
131 return false;
132
133 // If nothing in the Module uses ARC, don't do anything.
134 if (!ModuleHasARC(M))
135 return false;
136
137 // Find the llvm.global_ctors variable, as the first step in
138 // identifying the global constructors. In theory, unnecessary autorelease
139 // pools could occur anywhere, but in practice it's pretty rare. Global
140 // ctors are a place where autorelease pools get inserted automatically,
141 // so it's pretty common for them to be unnecessary, and it's pretty
142 // profitable to eliminate them.
143 GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors");
144 if (!GV)
145 return false;
146
147 assert(GV->hasDefinitiveInitializer() &&
148 "llvm.global_ctors is uncooperative!");
149
150 bool Changed = false;
151
152 // Dig the constructor functions out of GV's initializer.
153 ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
154 for (User::op_iterator OI = Init->op_begin(), OE = Init->op_end();
155 OI != OE; ++OI) {
156 Value *Op = *OI;
157 // llvm.global_ctors is an array of pairs where the second members
158 // are constructor functions.
159 Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));
160 // If the user used a constructor function with the wrong signature and
161 // it got bitcasted or whatever, look the other way.
162 if (!F)
163 continue;
164 // Only look at function definitions.
165 if (F->isDeclaration())
166 continue;
167 // Only look at functions with one basic block.
168 if (llvm::next(F->begin()) != F->end())
169 continue;
170 // Ok, a single-block constructor function definition. Try to optimize it.
171 Changed |= OptimizeBB(F->begin());
172 }
173
174 return Changed;
175 }
176