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