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/PassManager.h" 31 #include "llvm/IR/Value.h" 32 #include "llvm/InitializePasses.h" 33 #include "llvm/Pass.h" 34 #include "llvm/PassRegistry.h" 35 #include "llvm/Support/Casting.h" 36 #include "llvm/Support/Debug.h" 37 #include "llvm/Support/raw_ostream.h" 38 #include "llvm/Transforms/ObjCARC.h" 39 40 #define DEBUG_TYPE "objc-arc-expand" 41 42 using namespace llvm; 43 using namespace llvm::objcarc; 44 45 namespace { 46 static bool runImpl(Function &F) { 47 if (!EnableARCOpts) 48 return false; 49 50 // If nothing in the Module uses ARC, don't do anything. 51 if (!ModuleHasARC(*F.getParent())) 52 return false; 53 54 bool Changed = false; 55 56 LLVM_DEBUG(dbgs() << "ObjCARCExpand: Visiting Function: " << F.getName() 57 << "\n"); 58 59 for (Instruction &Inst : instructions(&F)) { 60 LLVM_DEBUG(dbgs() << "ObjCARCExpand: Visiting: " << Inst << "\n"); 61 62 switch (GetBasicARCInstKind(&Inst)) { 63 case ARCInstKind::Retain: 64 case ARCInstKind::RetainRV: 65 case ARCInstKind::Autorelease: 66 case ARCInstKind::AutoreleaseRV: 67 case ARCInstKind::FusedRetainAutorelease: 68 case ARCInstKind::FusedRetainAutoreleaseRV: { 69 // These calls return their argument verbatim, as a low-level 70 // optimization. However, this makes high-level optimizations 71 // harder. Undo any uses of this optimization that the front-end 72 // emitted here. We'll redo them in the contract pass. 73 Changed = true; 74 Value *Value = cast<CallInst>(&Inst)->getArgOperand(0); 75 LLVM_DEBUG(dbgs() << "ObjCARCExpand: Old = " << Inst 76 << "\n" 77 " New = " 78 << *Value << "\n"); 79 Inst.replaceAllUsesWith(Value); 80 break; 81 } 82 default: 83 break; 84 } 85 } 86 87 LLVM_DEBUG(dbgs() << "ObjCARCExpand: Finished List.\n\n"); 88 89 return Changed; 90 } 91 92 /// Early ARC transformations. 93 class ObjCARCExpand : public FunctionPass { 94 void getAnalysisUsage(AnalysisUsage &AU) const override; 95 bool runOnFunction(Function &F) override; 96 97 public: 98 static char ID; 99 ObjCARCExpand() : FunctionPass(ID) { 100 initializeObjCARCExpandPass(*PassRegistry::getPassRegistry()); 101 } 102 }; 103 } // namespace 104 105 char ObjCARCExpand::ID = 0; 106 INITIALIZE_PASS(ObjCARCExpand, "objc-arc-expand", "ObjC ARC expansion", false, 107 false) 108 109 Pass *llvm::createObjCARCExpandPass() { return new ObjCARCExpand(); } 110 111 void ObjCARCExpand::getAnalysisUsage(AnalysisUsage &AU) const { 112 AU.setPreservesCFG(); 113 } 114 115 bool ObjCARCExpand::runOnFunction(Function &F) { return runImpl(F); } 116 117 PreservedAnalyses ObjCARCExpandPass::run(Function &F, 118 FunctionAnalysisManager &AM) { 119 if (!runImpl(F)) 120 return PreservedAnalyses::all(); 121 PreservedAnalyses PA; 122 PA.preserveSet<CFGAnalyses>(); 123 return PA; 124 } 125