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/InitializePasses.h"
30 #include "llvm/Pass.h"
31
32 #define DEBUG_TYPE "objc-arc-aa"
33
34 using namespace llvm;
35 using namespace llvm::objcarc;
36
alias(const MemoryLocation & LocA,const MemoryLocation & LocB,AAQueryInfo & AAQI,const Instruction *)37 AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA,
38 const MemoryLocation &LocB,
39 AAQueryInfo &AAQI, const Instruction *) {
40 if (!EnableARCOpts)
41 return AAResultBase::alias(LocA, LocB, AAQI, nullptr);
42
43 // First, strip off no-ops, including ObjC-specific no-ops, and try making a
44 // precise alias query.
45 const Value *SA = GetRCIdentityRoot(LocA.Ptr);
46 const Value *SB = GetRCIdentityRoot(LocB.Ptr);
47 AliasResult Result = AAResultBase::alias(
48 MemoryLocation(SA, LocA.Size, LocA.AATags),
49 MemoryLocation(SB, LocB.Size, LocB.AATags), AAQI, nullptr);
50 if (Result != AliasResult::MayAlias)
51 return Result;
52
53 // If that failed, climb to the underlying object, including climbing through
54 // ObjC-specific no-ops, and try making an imprecise alias query.
55 const Value *UA = GetUnderlyingObjCPtr(SA);
56 const Value *UB = GetUnderlyingObjCPtr(SB);
57 if (UA != SA || UB != SB) {
58 Result = AAResultBase::alias(MemoryLocation::getBeforeOrAfter(UA),
59 MemoryLocation::getBeforeOrAfter(UB), AAQI,
60 nullptr);
61 // We can't use MustAlias or PartialAlias results here because
62 // GetUnderlyingObjCPtr may return an offsetted pointer value.
63 if (Result == AliasResult::NoAlias)
64 return AliasResult::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 AliasResult::MayAlias;
70 }
71
getModRefInfoMask(const MemoryLocation & Loc,AAQueryInfo & AAQI,bool IgnoreLocals)72 ModRefInfo ObjCARCAAResult::getModRefInfoMask(const MemoryLocation &Loc,
73 AAQueryInfo &AAQI,
74 bool IgnoreLocals) {
75 if (!EnableARCOpts)
76 return AAResultBase::getModRefInfoMask(Loc, AAQI, IgnoreLocals);
77
78 // First, strip off no-ops, including ObjC-specific no-ops, and try making
79 // a precise alias query.
80 const Value *S = GetRCIdentityRoot(Loc.Ptr);
81 if (isNoModRef(AAResultBase::getModRefInfoMask(
82 MemoryLocation(S, Loc.Size, Loc.AATags), AAQI, IgnoreLocals)))
83 return ModRefInfo::NoModRef;
84
85 // If that failed, climb to the underlying object, including climbing through
86 // ObjC-specific no-ops, and try making an imprecise alias query.
87 const Value *U = GetUnderlyingObjCPtr(S);
88 if (U != S)
89 return AAResultBase::getModRefInfoMask(MemoryLocation::getBeforeOrAfter(U),
90 AAQI, IgnoreLocals);
91
92 // If that failed, fail. We don't need to chain here, since that's covered
93 // by the earlier precise query.
94 return ModRefInfo::ModRef;
95 }
96
getMemoryEffects(const Function * F)97 MemoryEffects ObjCARCAAResult::getMemoryEffects(const Function *F) {
98 if (!EnableARCOpts)
99 return AAResultBase::getMemoryEffects(F);
100
101 switch (GetFunctionClass(F)) {
102 case ARCInstKind::NoopCast:
103 return MemoryEffects::none();
104 default:
105 break;
106 }
107
108 return AAResultBase::getMemoryEffects(F);
109 }
110
getModRefInfo(const CallBase * Call,const MemoryLocation & Loc,AAQueryInfo & AAQI)111 ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,
112 const MemoryLocation &Loc,
113 AAQueryInfo &AAQI) {
114 if (!EnableARCOpts)
115 return AAResultBase::getModRefInfo(Call, Loc, AAQI);
116
117 switch (GetBasicARCInstKind(Call)) {
118 case ARCInstKind::Retain:
119 case ARCInstKind::RetainRV:
120 case ARCInstKind::Autorelease:
121 case ARCInstKind::AutoreleaseRV:
122 case ARCInstKind::NoopCast:
123 case ARCInstKind::AutoreleasepoolPush:
124 case ARCInstKind::FusedRetainAutorelease:
125 case ARCInstKind::FusedRetainAutoreleaseRV:
126 // These functions don't access any memory visible to the compiler.
127 // Note that this doesn't include objc_retainBlock, because it updates
128 // pointers when it copies block data.
129 return ModRefInfo::NoModRef;
130 default:
131 break;
132 }
133
134 return AAResultBase::getModRefInfo(Call, Loc, AAQI);
135 }
136
137 AnalysisKey ObjCARCAA::Key;
138
run(Function & F,FunctionAnalysisManager & AM)139 ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
140 return ObjCARCAAResult(F.getParent()->getDataLayout());
141 }
142