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 34using namespace llvm; 35using namespace llvm::objcarc; 36 37namespace { 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; 48 ObjCARCAPElim() : ModulePass(ID) { 49 initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry()); 50 } 51 }; 52} 53 54char ObjCARCAPElim::ID = 0; 55INITIALIZE_PASS(ObjCARCAPElim, 56 "objc-arc-apelim", 57 "ObjC ARC autorelease pool elimination", 58 false, false) 59 60Pass *llvm::createObjCARCAPElimPass() { 61 return new ObjCARCAPElim(); 62} 63 64void 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. 70bool 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 93bool 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 129bool 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