LLVM  10.0.0svn
ObjCARCExpand.cpp
Go to the documentation of this file.
1 //===- ObjCARCExpand.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 /// This file defines ObjC ARC optimizations. ARC stands for Automatic
10 /// Reference Counting and is a system for managing reference counts for objects
11 /// in Objective C.
12 ///
13 /// This specific file deals with early optimizations which perform certain
14 /// cleanup operations.
15 ///
16 /// WARNING: This file knows about certain library functions. It recognizes them
17 /// by name, and hardwires knowledge of their semantics.
18 ///
19 /// WARNING: This file knows about how certain Objective-C library functions are
20 /// used. Naive LLVM IR transformations which would otherwise be
21 /// behavior-preserving may break these assumptions.
22 ///
23 //===----------------------------------------------------------------------===//
24 
25 #include "ObjCARC.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/InstIterator.h"
28 #include "llvm/IR/Instruction.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Value.h"
31 #include "llvm/Pass.h"
33 #include "llvm/PassRegistry.h"
34 #include "llvm/PassSupport.h"
35 #include "llvm/Support/Casting.h"
36 #include "llvm/Support/Debug.h"
38 
39 #define DEBUG_TYPE "objc-arc-expand"
40 
41 namespace llvm {
42  class Module;
43 }
44 
45 using namespace llvm;
46 using namespace llvm::objcarc;
47 
48 namespace {
49  /// Early ARC transformations.
50  class ObjCARCExpand : public FunctionPass {
51  void getAnalysisUsage(AnalysisUsage &AU) const override;
52  bool doInitialization(Module &M) override;
53  bool runOnFunction(Function &F) override;
54 
55  /// A flag indicating whether this optimization pass should run.
56  bool Run;
57 
58  public:
59  static char ID;
60  ObjCARCExpand() : FunctionPass(ID) {
62  }
63  };
64 }
65 
66 char ObjCARCExpand::ID = 0;
67 INITIALIZE_PASS(ObjCARCExpand,
68  "objc-arc-expand", "ObjC ARC expansion", false, false)
69 
71  return new ObjCARCExpand();
72 }
73 
74 void ObjCARCExpand::getAnalysisUsage(AnalysisUsage &AU) const {
75  AU.setPreservesCFG();
76 }
77 
78 bool ObjCARCExpand::doInitialization(Module &M) {
79  Run = ModuleHasARC(M);
80  return false;
81 }
82 
84  if (!EnableARCOpts)
85  return false;
86 
87  // If nothing in the Module uses ARC, don't do anything.
88  if (!Run)
89  return false;
90 
91  bool Changed = false;
92 
93  LLVM_DEBUG(dbgs() << "ObjCARCExpand: Visiting Function: " << F.getName()
94  << "\n");
95 
96  for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
97  Instruction *Inst = &*I;
98 
99  LLVM_DEBUG(dbgs() << "ObjCARCExpand: Visiting: " << *Inst << "\n");
100 
101  switch (GetBasicARCInstKind(Inst)) {
102  case ARCInstKind::Retain:
108  // These calls return their argument verbatim, as a low-level
109  // optimization. However, this makes high-level optimizations
110  // harder. Undo any uses of this optimization that the front-end
111  // emitted here. We'll redo them in the contract pass.
112  Changed = true;
113  Value *Value = cast<CallInst>(Inst)->getArgOperand(0);
114  LLVM_DEBUG(dbgs() << "ObjCARCExpand: Old = " << *Inst
115  << "\n"
116  " New = "
117  << *Value << "\n");
118  Inst->replaceAllUsesWith(Value);
119  break;
120  }
121  default:
122  break;
123  }
124  }
125 
126  LLVM_DEBUG(dbgs() << "ObjCARCExpand: Finished List.\n\n");
127 
128  return Changed;
129 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
F(f)
objc_autoreleaseReturnValue
inst_iterator inst_begin(Function *F)
Definition: InstIterator.h:131
This file defines common definitions/declarations used by the ObjC ARC Optimizer. ...
objc_retainAutoreleasedReturnValue
bool EnableARCOpts
A handy option to enable/disable all ARC Optimizations.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:429
bool ModuleHasARC(const Module &M)
Test if the given module looks interesting to run ARC optimization on.
static bool runOnFunction(Function &F, bool PostInlining)
Pass * createObjCARCExpandPass()
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
ARCInstKind GetBasicARCInstKind(const Value *V)
Determine which objc runtime call instruction class V belongs to.
INITIALIZE_PASS(ObjCARCExpand, "objc-arc-expand", "ObjC ARC expansion", false, false) Pass *llvm
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:301
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
#define I(x, y, z)
Definition: MD5.cpp:58
LLVM Value Representation.
Definition: Value.h:73
inst_iterator inst_end(Function *F)
Definition: InstIterator.h:132
#define LLVM_DEBUG(X)
Definition: Debug.h:122
void initializeObjCARCExpandPass(PassRegistry &)