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 #include "ObjCARC.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/IR/Constants.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/raw_ostream.h"
32
33 using namespace llvm;
34 using namespace llvm::objcarc;
35
36 #define DEBUG_TYPE "objc-arc-ap-elim"
37
38 namespace {
39 /// \brief Autorelease pool elimination.
40 class ObjCARCAPElim : public ModulePass {
41 void getAnalysisUsage(AnalysisUsage &AU) const override;
42 bool runOnModule(Module &M) override;
43
44 static bool MayAutorelease(ImmutableCallSite CS, unsigned Depth = 0);
45 static bool OptimizeBB(BasicBlock *BB);
46
47 public:
48 static char ID;
ObjCARCAPElim()49 ObjCARCAPElim() : ModulePass(ID) {
50 initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry());
51 }
52 };
53 }
54
55 char ObjCARCAPElim::ID = 0;
56 INITIALIZE_PASS(ObjCARCAPElim,
57 "objc-arc-apelim",
58 "ObjC ARC autorelease pool elimination",
59 false, false)
60
createObjCARCAPElimPass()61 Pass *llvm::createObjCARCAPElimPass() {
62 return new ObjCARCAPElim();
63 }
64
getAnalysisUsage(AnalysisUsage & AU) const65 void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const {
66 AU.setPreservesCFG();
67 }
68
69 /// Interprocedurally determine if calls made by the given call site can
70 /// possibly produce autoreleases.
MayAutorelease(ImmutableCallSite CS,unsigned Depth)71 bool ObjCARCAPElim::MayAutorelease(ImmutableCallSite CS, unsigned Depth) {
72 if (const Function *Callee = CS.getCalledFunction()) {
73 if (Callee->isDeclaration() || Callee->mayBeOverridden())
74 return true;
75 for (Function::const_iterator I = Callee->begin(), E = Callee->end();
76 I != E; ++I) {
77 const BasicBlock *BB = I;
78 for (BasicBlock::const_iterator J = BB->begin(), F = BB->end();
79 J != F; ++J)
80 if (ImmutableCallSite JCS = ImmutableCallSite(J))
81 // This recursion depth limit is arbitrary. It's just great
82 // enough to cover known interesting testcases.
83 if (Depth < 3 &&
84 !JCS.onlyReadsMemory() &&
85 MayAutorelease(JCS, Depth + 1))
86 return true;
87 }
88 return false;
89 }
90
91 return true;
92 }
93
OptimizeBB(BasicBlock * BB)94 bool ObjCARCAPElim::OptimizeBB(BasicBlock *BB) {
95 bool Changed = false;
96
97 Instruction *Push = nullptr;
98 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
99 Instruction *Inst = I++;
100 switch (GetBasicARCInstKind(Inst)) {
101 case ARCInstKind::AutoreleasepoolPush:
102 Push = Inst;
103 break;
104 case ARCInstKind::AutoreleasepoolPop:
105 // If this pop matches a push and nothing in between can autorelease,
106 // zap the pair.
107 if (Push && cast<CallInst>(Inst)->getArgOperand(0) == Push) {
108 Changed = true;
109 DEBUG(dbgs() << "ObjCARCAPElim::OptimizeBB: Zapping push pop "
110 "autorelease pair:\n"
111 " Pop: " << *Inst << "\n"
112 << " Push: " << *Push << "\n");
113 Inst->eraseFromParent();
114 Push->eraseFromParent();
115 }
116 Push = nullptr;
117 break;
118 case ARCInstKind::CallOrUser:
119 if (MayAutorelease(ImmutableCallSite(Inst)))
120 Push = nullptr;
121 break;
122 default:
123 break;
124 }
125 }
126
127 return Changed;
128 }
129
runOnModule(Module & M)130 bool ObjCARCAPElim::runOnModule(Module &M) {
131 if (!EnableARCOpts)
132 return false;
133
134 // If nothing in the Module uses ARC, don't do anything.
135 if (!ModuleHasARC(M))
136 return false;
137
138 // Find the llvm.global_ctors variable, as the first step in
139 // identifying the global constructors. In theory, unnecessary autorelease
140 // pools could occur anywhere, but in practice it's pretty rare. Global
141 // ctors are a place where autorelease pools get inserted automatically,
142 // so it's pretty common for them to be unnecessary, and it's pretty
143 // profitable to eliminate them.
144 GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors");
145 if (!GV)
146 return false;
147
148 assert(GV->hasDefinitiveInitializer() &&
149 "llvm.global_ctors is uncooperative!");
150
151 bool Changed = false;
152
153 // Dig the constructor functions out of GV's initializer.
154 ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
155 for (User::op_iterator OI = Init->op_begin(), OE = Init->op_end();
156 OI != OE; ++OI) {
157 Value *Op = *OI;
158 // llvm.global_ctors is an array of three-field structs where the second
159 // members are constructor functions.
160 Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));
161 // If the user used a constructor function with the wrong signature and
162 // it got bitcasted or whatever, look the other way.
163 if (!F)
164 continue;
165 // Only look at function definitions.
166 if (F->isDeclaration())
167 continue;
168 // Only look at functions with one basic block.
169 if (std::next(F->begin()) != F->end())
170 continue;
171 // Ok, a single-block constructor function definition. Try to optimize it.
172 Changed |= OptimizeBB(F->begin());
173 }
174
175 return Changed;
176 }
177