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