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