1 //===- ObjCARCAPElim.cpp - ObjC ARC Optimization --------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// 10 /// This file defines ObjC ARC optimizations. ARC stands for Automatic 11 /// Reference Counting and is a system for managing reference counts for objects 12 /// in Objective C. 13 /// 14 /// This specific file implements optimizations which remove extraneous 15 /// autorelease pools. 16 /// 17 /// WARNING: This file knows about certain library functions. It recognizes them 18 /// by name, and hardwires knowledge of their semantics. 19 /// 20 /// WARNING: This file knows about how certain Objective-C library functions are 21 /// used. Naive LLVM IR transformations which would otherwise be 22 /// behavior-preserving may break these assumptions. 23 /// 24 //===----------------------------------------------------------------------===// 25 26 #include "ObjCARC.h" 27 #include "llvm/ADT/STLExtras.h" 28 #include "llvm/IR/Constants.h" 29 #include "llvm/InitializePasses.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 /// 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(const CallBase &CB, 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 55 char ObjCARCAPElim::ID = 0; 56 INITIALIZE_PASS(ObjCARCAPElim, 57 "objc-arc-apelim", 58 "ObjC ARC autorelease pool elimination", 59 false, false) 60 61 Pass *llvm::createObjCARCAPElimPass() { 62 return new ObjCARCAPElim(); 63 } 64 65 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. 71 bool ObjCARCAPElim::MayAutorelease(const CallBase &CB, unsigned Depth) { 72 if (const Function *Callee = CB.getCalledFunction()) { 73 if (!Callee->hasExactDefinition()) 74 return true; 75 for (const BasicBlock &BB : *Callee) { 76 for (const Instruction &I : BB) 77 if (const CallBase *JCB = dyn_cast<CallBase>(&I)) 78 // This recursion depth limit is arbitrary. It's just great 79 // enough to cover known interesting testcases. 80 if (Depth < 3 && !JCB->onlyReadsMemory() && 81 MayAutorelease(*JCB, Depth + 1)) 82 return true; 83 } 84 return false; 85 } 86 87 return true; 88 } 89 90 bool ObjCARCAPElim::OptimizeBB(BasicBlock *BB) { 91 bool Changed = false; 92 93 Instruction *Push = nullptr; 94 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) { 95 Instruction *Inst = &*I++; 96 switch (GetBasicARCInstKind(Inst)) { 97 case ARCInstKind::AutoreleasepoolPush: 98 Push = Inst; 99 break; 100 case ARCInstKind::AutoreleasepoolPop: 101 // If this pop matches a push and nothing in between can autorelease, 102 // zap the pair. 103 if (Push && cast<CallInst>(Inst)->getArgOperand(0) == Push) { 104 Changed = true; 105 LLVM_DEBUG(dbgs() << "ObjCARCAPElim::OptimizeBB: Zapping push pop " 106 "autorelease pair:\n" 107 " Pop: " 108 << *Inst << "\n" 109 << " Push: " << *Push 110 << "\n"); 111 Inst->eraseFromParent(); 112 Push->eraseFromParent(); 113 } 114 Push = nullptr; 115 break; 116 case ARCInstKind::CallOrUser: 117 if (MayAutorelease(cast<CallBase>(*Inst))) 118 Push = nullptr; 119 break; 120 default: 121 break; 122 } 123 } 124 125 return Changed; 126 } 127 128 bool ObjCARCAPElim::runOnModule(Module &M) { 129 if (!EnableARCOpts) 130 return false; 131 132 // If nothing in the Module uses ARC, don't do anything. 133 if (!ModuleHasARC(M)) 134 return false; 135 136 if (skipModule(M)) 137 return false; 138 139 // Find the llvm.global_ctors variable, as the first step in 140 // identifying the global constructors. In theory, unnecessary autorelease 141 // pools could occur anywhere, but in practice it's pretty rare. Global 142 // ctors are a place where autorelease pools get inserted automatically, 143 // so it's pretty common for them to be unnecessary, and it's pretty 144 // profitable to eliminate them. 145 GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors"); 146 if (!GV) 147 return false; 148 149 assert(GV->hasDefinitiveInitializer() && 150 "llvm.global_ctors is uncooperative!"); 151 152 bool Changed = false; 153 154 // Dig the constructor functions out of GV's initializer. 155 ConstantArray *Init = cast<ConstantArray>(GV->getInitializer()); 156 for (User::op_iterator OI = Init->op_begin(), OE = Init->op_end(); 157 OI != OE; ++OI) { 158 Value *Op = *OI; 159 // llvm.global_ctors is an array of three-field structs where the second 160 // members are constructor functions. 161 Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1)); 162 // If the user used a constructor function with the wrong signature and 163 // it got bitcasted or whatever, look the other way. 164 if (!F) 165 continue; 166 // Only look at function definitions. 167 if (F->isDeclaration()) 168 continue; 169 // Only look at functions with one basic block. 170 if (std::next(F->begin()) != F->end()) 171 continue; 172 // Ok, a single-block constructor function definition. Try to optimize it. 173 Changed |= OptimizeBB(&F->front()); 174 } 175 176 return Changed; 177 } 178