Home | History | Annotate | Download | only in ObjCARC 
      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 (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 
     91 bool 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 
    127 bool 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