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/IR/PassManager.h"
30 #include "llvm/InitializePasses.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/raw_ostream.h"
33 #include "llvm/Transforms/ObjCARC.h"
34 
35 using namespace llvm;
36 using namespace llvm::objcarc;
37 
38 #define DEBUG_TYPE "objc-arc-ap-elim"
39 
EraseInstruction(Instruction * CI)40 namespace {
41 
42 /// Interprocedurally determine if calls made by the given call site can
43 /// possibly produce autoreleases.
44 bool MayAutorelease(const CallBase &CB, unsigned Depth = 0) {
45   if (const Function *Callee = CB.getCalledFunction()) {
46     if (!Callee->hasExactDefinition())
47       return true;
48     for (const BasicBlock &BB : *Callee) {
49       for (const Instruction &I : BB)
50         if (const CallBase *JCB = dyn_cast<CallBase>(&I))
51           // This recursion depth limit is arbitrary. It's just great
52           // enough to cover known interesting testcases.
53           if (Depth < 3 && !JCB->onlyReadsMemory() &&
54               MayAutorelease(*JCB, Depth + 1))
55             return true;
56     }
57     return false;
58   }
59 
60   return true;
61 }
62 
63 bool OptimizeBB(BasicBlock *BB) {
64   bool Changed = false;
65 
66   Instruction *Push = nullptr;
67   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
68     Instruction *Inst = &*I++;
69     switch (GetBasicARCInstKind(Inst)) {
70     case ARCInstKind::AutoreleasepoolPush:
71       Push = Inst;
72       break;
73     case ARCInstKind::AutoreleasepoolPop:
74       // If this pop matches a push and nothing in between can autorelease,
75       // zap the pair.
76       if (Push && cast<CallInst>(Inst)->getArgOperand(0) == Push) {
77         Changed = true;
78         LLVM_DEBUG(dbgs() << "ObjCARCAPElim::OptimizeBB: Zapping push pop "
79                              "autorelease pair:\n"
80                              "                           Pop: "
81                           << *Inst << "\n"
82                           << "                           Push: " << *Push
83                           << "\n");
84         Inst->eraseFromParent();
85         Push->eraseFromParent();
86       }
87       Push = nullptr;
88       break;
89     case ARCInstKind::CallOrUser:
90       if (MayAutorelease(cast<CallBase>(*Inst)))
91         Push = nullptr;
92       break;
93     default:
94       break;
95     }
96   }
97 
98   return Changed;
99 }
100 
101 bool runImpl(Module &M) {
102   if (!EnableARCOpts)
103     return false;
104 
105   // If nothing in the Module uses ARC, don't do anything.
106   if (!ModuleHasARC(M))
107     return false;
108   // Find the llvm.global_ctors variable, as the first step in
109   // identifying the global constructors. In theory, unnecessary autorelease
110   // pools could occur anywhere, but in practice it's pretty rare. Global
111   // ctors are a place where autorelease pools get inserted automatically,
112   // so it's pretty common for them to be unnecessary, and it's pretty
113   // profitable to eliminate them.
114   GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors");
115   if (!GV)
116     return false;
117 
118   assert(GV->hasDefinitiveInitializer() &&
119          "llvm.global_ctors is uncooperative!");
120 
121   bool Changed = false;
122 
123   // Dig the constructor functions out of GV's initializer.
124   ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
125   for (User::op_iterator OI = Init->op_begin(), OE = Init->op_end();
126        OI != OE; ++OI) {
127     Value *Op = *OI;
128     // llvm.global_ctors is an array of three-field structs where the second
129     // members are constructor functions.
130     Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));
131     // If the user used a constructor function with the wrong signature and
132     // it got bitcasted or whatever, look the other way.
133     if (!F)
134       continue;
135     // Only look at function definitions.
136     if (F->isDeclaration())
137       continue;
138     // Only look at functions with one basic block.
139     if (std::next(F->begin()) != F->end())
140       continue;
141     // Ok, a single-block constructor function definition. Try to optimize it.
142     Changed |= OptimizeBB(&F->front());
143   }
144 
145   return Changed;
146 }
147 
148 /// Autorelease pool elimination.
149 class ObjCARCAPElim : public ModulePass {
150   void getAnalysisUsage(AnalysisUsage &AU) const override;
151   bool runOnModule(Module &M) override;
152 
153 public:
154   static char ID;
155   ObjCARCAPElim() : ModulePass(ID) {
156     initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry());
157   }
158 };
159 } // namespace
160 
161 char ObjCARCAPElim::ID = 0;
162 INITIALIZE_PASS(ObjCARCAPElim, "objc-arc-apelim",
163                 "ObjC ARC autorelease pool elimination", false, false)
164 
165 Pass *llvm::createObjCARCAPElimPass() { return new ObjCARCAPElim(); }
166 
167 void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const {
168   AU.setPreservesCFG();
169 }
170 
171 bool ObjCARCAPElim::runOnModule(Module &M) {
172   if (skipModule(M))
173     return false;
174   return runImpl(M);
175 }
176 
177 PreservedAnalyses ObjCARCAPElimPass::run(Module &M, ModuleAnalysisManager &AM) {
178   if (!runImpl(M))
179     return PreservedAnalyses::all();
180   PreservedAnalyses PA;
181   PA.preserveSet<CFGAnalyses>();
182   return PA;
183 }
184