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/IR/Function.h"
28 #include "llvm/IR/Instruction.h"
29 #include "llvm/IR/Value.h"
30 #include "llvm/InitializePasses.h"
31 #include "llvm/PassAnalysisSupport.h"
32 #include "llvm/PassSupport.h"
33 
34 #define DEBUG_TYPE "objc-arc-aa"
35 
36 using namespace llvm;
37 using namespace llvm::objcarc;
38 
alias(const MemoryLocation & LocA,const MemoryLocation & LocB,AAQueryInfo & AAQI)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 
pointsToConstantMemory(const MemoryLocation & Loc,AAQueryInfo & AAQI,bool OrLocal)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 
getModRefBehavior(const Function * F)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 
getModRefInfo(const CallBase * Call,const MemoryLocation & Loc,AAQueryInfo & AAQI)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 
run(Function & F,FunctionAnalysisManager & AM)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 
createObjCARCAAWrapperPass()144 ImmutablePass *llvm::createObjCARCAAWrapperPass() {
145   return new ObjCARCAAWrapperPass();
146 }
147 
ObjCARCAAWrapperPass()148 ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
149   initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
150 }
151 
doInitialization(Module & M)152 bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
153   Result.reset(new ObjCARCAAResult(M.getDataLayout()));
154   return false;
155 }
156 
doFinalization(Module & M)157 bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
158   Result.reset();
159   return false;
160 }
161 
getAnalysisUsage(AnalysisUsage & AU) const162 void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
163   AU.setPreservesAll();
164 }
165