lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

   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;
  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(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
  94 bool ObjCARCAPElim::OptimizeBB(BasicBlock *BB) {
  95   bool Changed = false;
  96
  97   Instruction *Push = 0;
  98   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
  99     Instruction *Inst = I++;
 100     switch (GetBasicInstructionClass(Inst)) {
 101     case IC_AutoreleasepoolPush:
 102       Push = Inst;
 103       break;
 104     case IC_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 = 0;
 117       break;
 118     case IC_CallOrUser:
 119       if (MayAutorelease(ImmutableCallSite(Inst)))
 120         Push = 0;
 121       break;
 122     default:
 123       break;
 124     }
 125   }
 126
 127   return Changed;
 128 }
 129
 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 pairs where the second members
 159     // 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 }