1//===- ObjCARCAliasAnalysis.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/// This file defines a simple ARC-aware AliasAnalysis using special knowledge 11/// of Objective C to enhance other optimization passes which rely on the Alias 12/// Analysis infrastructure. 13/// 14/// WARNING: This file knows about certain library functions. It recognizes them 15/// by name, and hardwires knowledge of their semantics. 16/// 17/// WARNING: This file knows about how certain Objective-C library functions are 18/// used. Naive LLVM IR transformations which would otherwise be 19/// behavior-preserving may break these assumptions. 20/// 21/// TODO: Theoretically we could check for dependencies between objc_* calls 22/// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls. 23/// 24//===----------------------------------------------------------------------===// 25 26#include "llvm/Analysis/ObjCARCAliasAnalysis.h" 27#include "llvm/Analysis/ObjCARCAnalysisUtils.h" 28#include "llvm/IR/Function.h" 29#include "llvm/IR/Instruction.h" 30#include "llvm/IR/Value.h" 31#include "llvm/InitializePasses.h" 32#include "llvm/PassAnalysisSupport.h" 33#include "llvm/PassSupport.h" 34 35#define DEBUG_TYPE "objc-arc-aa" 36 37using namespace llvm; 38using namespace llvm::objcarc; 39 40AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA, 41 const MemoryLocation &LocB) { 42 if (!EnableARCOpts) 43 return AAResultBase::alias(LocA, LocB); 44 45 // First, strip off no-ops, including ObjC-specific no-ops, and try making a 46 // precise alias query. 47 const Value *SA = GetRCIdentityRoot(LocA.Ptr); 48 const Value *SB = GetRCIdentityRoot(LocB.Ptr); 49 AliasResult Result = 50 AAResultBase::alias(MemoryLocation(SA, LocA.Size, LocA.AATags), 51 MemoryLocation(SB, LocB.Size, LocB.AATags)); 52 if (Result != MayAlias) 53 return Result; 54 55 // If that failed, climb to the underlying object, including climbing through 56 // ObjC-specific no-ops, and try making an imprecise alias query. 57 const Value *UA = GetUnderlyingObjCPtr(SA, DL); 58 const Value *UB = GetUnderlyingObjCPtr(SB, DL); 59 if (UA != SA || UB != SB) { 60 Result = AAResultBase::alias(MemoryLocation(UA), MemoryLocation(UB)); 61 // We can't use MustAlias or PartialAlias results here because 62 // GetUnderlyingObjCPtr may return an offsetted pointer value. 63 if (Result == NoAlias) 64 return NoAlias; 65 } 66 67 // If that failed, fail. We don't need to chain here, since that's covered 68 // by the earlier precise query. 69 return MayAlias; 70} 71 72bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc, 73 bool OrLocal) { 74 if (!EnableARCOpts) 75 return AAResultBase::pointsToConstantMemory(Loc, OrLocal); 76 77 // First, strip off no-ops, including ObjC-specific no-ops, and try making 78 // a precise alias query. 79 const Value *S = GetRCIdentityRoot(Loc.Ptr); 80 if (AAResultBase::pointsToConstantMemory( 81 MemoryLocation(S, Loc.Size, Loc.AATags), OrLocal)) 82 return true; 83 84 // If that failed, climb to the underlying object, including climbing through 85 // ObjC-specific no-ops, and try making an imprecise alias query. 86 const Value *U = GetUnderlyingObjCPtr(S, DL); 87 if (U != S) 88 return AAResultBase::pointsToConstantMemory(MemoryLocation(U), OrLocal); 89 90 // If that failed, fail. We don't need to chain here, since that's covered 91 // by the earlier precise query. 92 return false; 93} 94 95FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) { 96 if (!EnableARCOpts) 97 return AAResultBase::getModRefBehavior(F); 98 99 switch (GetFunctionClass(F)) { 100 case ARCInstKind::NoopCast: 101 return FMRB_DoesNotAccessMemory; 102 default: 103 break; 104 } 105 106 return AAResultBase::getModRefBehavior(F); 107} 108 109ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS, 110 const MemoryLocation &Loc) { 111 if (!EnableARCOpts) 112 return AAResultBase::getModRefInfo(CS, Loc); 113 114 switch (GetBasicARCInstKind(CS.getInstruction())) { 115 case ARCInstKind::Retain: 116 case ARCInstKind::RetainRV: 117 case ARCInstKind::Autorelease: 118 case ARCInstKind::AutoreleaseRV: 119 case ARCInstKind::NoopCast: 120 case ARCInstKind::AutoreleasepoolPush: 121 case ARCInstKind::FusedRetainAutorelease: 122 case ARCInstKind::FusedRetainAutoreleaseRV: 123 // These functions don't access any memory visible to the compiler. 124 // Note that this doesn't include objc_retainBlock, because it updates 125 // pointers when it copies block data. 126 return MRI_NoModRef; 127 default: 128 break; 129 } 130 131 return AAResultBase::getModRefInfo(CS, Loc); 132} 133 134ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> *AM) { 135 return ObjCARCAAResult(F.getParent()->getDataLayout(), 136 AM->getResult<TargetLibraryAnalysis>(F)); 137} 138 139char ObjCARCAA::PassID; 140 141char ObjCARCAAWrapperPass::ID = 0; 142INITIALIZE_PASS_BEGIN(ObjCARCAAWrapperPass, "objc-arc-aa", 143 "ObjC-ARC-Based Alias Analysis", false, true) 144INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) 145INITIALIZE_PASS_END(ObjCARCAAWrapperPass, "objc-arc-aa", 146 "ObjC-ARC-Based Alias Analysis", false, true) 147 148ImmutablePass *llvm::createObjCARCAAWrapperPass() { 149 return new ObjCARCAAWrapperPass(); 150} 151 152ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) { 153 initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry()); 154} 155 156bool ObjCARCAAWrapperPass::doInitialization(Module &M) { 157 Result.reset(new ObjCARCAAResult( 158 M.getDataLayout(), getAnalysis<TargetLibraryInfoWrapperPass>().getTLI())); 159 return false; 160} 161 162bool ObjCARCAAWrapperPass::doFinalization(Module &M) { 163 Result.reset(); 164 return false; 165} 166 167void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const { 168 AU.setPreservesAll(); 169 AU.addRequired<TargetLibraryInfoWrapperPass>(); 170} 171