1 //===- ObjCARCAliasAnalysis.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 a simple ARC-aware AliasAnalysis using special knowledge 10 /// of Objective C to enhance other optimization passes which rely on the Alias 11 /// Analysis infrastructure. 12 /// 13 /// WARNING: This file knows about certain library functions. It recognizes them 14 /// by name, and hardwires knowledge of their semantics. 15 /// 16 /// WARNING: This file knows about how certain Objective-C library functions are 17 /// used. Naive LLVM IR transformations which would otherwise be 18 /// behavior-preserving may break these assumptions. 19 /// 20 /// TODO: Theoretically we could check for dependencies between objc_* calls 21 /// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls. 22 /// 23 //===----------------------------------------------------------------------===// 24 25 #include "llvm/Analysis/ObjCARCAliasAnalysis.h" 26 #include "llvm/Analysis/ObjCARCAnalysisUtils.h" 27 #include "llvm/Analysis/Passes.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/Pass.h" 33 34 #define DEBUG_TYPE "objc-arc-aa" 35 36 using namespace llvm; 37 using namespace llvm::objcarc; 38 39 AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA, 40 const MemoryLocation &LocB, 41 AAQueryInfo &AAQI) { 42 if (!EnableARCOpts) 43 return AAResultBase::alias(LocA, LocB, AAQI); 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), AAQI); 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), AAQI); 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 72 bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc, 73 AAQueryInfo &AAQI, bool OrLocal) { 74 if (!EnableARCOpts) 75 return AAResultBase::pointsToConstantMemory(Loc, AAQI, 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), AAQI, 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), AAQI, 89 OrLocal); 90 91 // If that failed, fail. We don't need to chain here, since that's covered 92 // by the earlier precise query. 93 return false; 94 } 95 96 FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) { 97 if (!EnableARCOpts) 98 return AAResultBase::getModRefBehavior(F); 99 100 switch (GetFunctionClass(F)) { 101 case ARCInstKind::NoopCast: 102 return FMRB_DoesNotAccessMemory; 103 default: 104 break; 105 } 106 107 return AAResultBase::getModRefBehavior(F); 108 } 109 110 ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call, 111 const MemoryLocation &Loc, 112 AAQueryInfo &AAQI) { 113 if (!EnableARCOpts) 114 return AAResultBase::getModRefInfo(Call, Loc, AAQI); 115 116 switch (GetBasicARCInstKind(Call)) { 117 case ARCInstKind::Retain: 118 case ARCInstKind::RetainRV: 119 case ARCInstKind::Autorelease: 120 case ARCInstKind::AutoreleaseRV: 121 case ARCInstKind::NoopCast: 122 case ARCInstKind::AutoreleasepoolPush: 123 case ARCInstKind::FusedRetainAutorelease: 124 case ARCInstKind::FusedRetainAutoreleaseRV: 125 // These functions don't access any memory visible to the compiler. 126 // Note that this doesn't include objc_retainBlock, because it updates 127 // pointers when it copies block data. 128 return ModRefInfo::NoModRef; 129 default: 130 break; 131 } 132 133 return AAResultBase::getModRefInfo(Call, Loc, AAQI); 134 } 135 136 ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) { 137 return ObjCARCAAResult(F.getParent()->getDataLayout()); 138 } 139 140 char ObjCARCAAWrapperPass::ID = 0; 141 INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa", 142 "ObjC-ARC-Based Alias Analysis", false, true) 143 144 ImmutablePass *llvm::createObjCARCAAWrapperPass() { 145 return new ObjCARCAAWrapperPass(); 146 } 147 148 ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) { 149 initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry()); 150 } 151 152 bool ObjCARCAAWrapperPass::doInitialization(Module &M) { 153 Result.reset(new ObjCARCAAResult(M.getDataLayout())); 154 return false; 155 } 156 157 bool ObjCARCAAWrapperPass::doFinalization(Module &M) { 158 Result.reset(); 159 return false; 160 } 161 162 void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const { 163 AU.setPreservesAll(); 164 } 165