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