1 //===- ObjCARCAliasAnalysis.cpp - ObjC ARC Optimization -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
14 /// WARNING: This file knows about certain library functions. It recognizes them
15 /// by name, and hardwires knowledge of their semantics.
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.
21 //===----------------------------------------------------------------------===//
24 #include "ObjCARCAliasAnalysis.h"
25 #include "llvm/IR/Instruction.h"
26 #include "llvm/InitializePasses.h"
27 #include "llvm/PassAnalysisSupport.h"
28 #include "llvm/PassSupport.h"
30 #define DEBUG_TYPE "objc-arc-aa"
38 using namespace llvm::objcarc
;
40 // Register this pass...
41 char ObjCARCAliasAnalysis::ID
= 0;
42 INITIALIZE_AG_PASS(ObjCARCAliasAnalysis
, AliasAnalysis
, "objc-arc-aa",
43 "ObjC-ARC-Based Alias Analysis", false, true, false)
45 ImmutablePass
*llvm::createObjCARCAliasAnalysisPass() {
46 return new ObjCARCAliasAnalysis();
50 ObjCARCAliasAnalysis::getAnalysisUsage(AnalysisUsage
&AU
) const {
52 AliasAnalysis::getAnalysisUsage(AU
);
55 AliasAnalysis::AliasResult
56 ObjCARCAliasAnalysis::alias(const Location
&LocA
, const Location
&LocB
) {
58 return AliasAnalysis::alias(LocA
, LocB
);
60 // First, strip off no-ops, including ObjC-specific no-ops, and try making a
61 // precise alias query.
62 const Value
*SA
= StripPointerCastsAndObjCCalls(LocA
.Ptr
);
63 const Value
*SB
= StripPointerCastsAndObjCCalls(LocB
.Ptr
);
65 AliasAnalysis::alias(Location(SA
, LocA
.Size
, LocA
.AATags
),
66 Location(SB
, LocB
.Size
, LocB
.AATags
));
67 if (Result
!= MayAlias
)
70 // If that failed, climb to the underlying object, including climbing through
71 // ObjC-specific no-ops, and try making an imprecise alias query.
72 const Value
*UA
= GetUnderlyingObjCPtr(SA
);
73 const Value
*UB
= GetUnderlyingObjCPtr(SB
);
74 if (UA
!= SA
|| UB
!= SB
) {
75 Result
= AliasAnalysis::alias(Location(UA
), Location(UB
));
76 // We can't use MustAlias or PartialAlias results here because
77 // GetUnderlyingObjCPtr may return an offsetted pointer value.
78 if (Result
== NoAlias
)
82 // If that failed, fail. We don't need to chain here, since that's covered
83 // by the earlier precise query.
88 ObjCARCAliasAnalysis::pointsToConstantMemory(const Location
&Loc
,
91 return AliasAnalysis::pointsToConstantMemory(Loc
, OrLocal
);
93 // First, strip off no-ops, including ObjC-specific no-ops, and try making
94 // a precise alias query.
95 const Value
*S
= StripPointerCastsAndObjCCalls(Loc
.Ptr
);
96 if (AliasAnalysis::pointsToConstantMemory(Location(S
, Loc
.Size
, Loc
.AATags
),
100 // If that failed, climb to the underlying object, including climbing through
101 // ObjC-specific no-ops, and try making an imprecise alias query.
102 const Value
*U
= GetUnderlyingObjCPtr(S
);
104 return AliasAnalysis::pointsToConstantMemory(Location(U
), OrLocal
);
106 // If that failed, fail. We don't need to chain here, since that's covered
107 // by the earlier precise query.
111 AliasAnalysis::ModRefBehavior
112 ObjCARCAliasAnalysis::getModRefBehavior(ImmutableCallSite CS
) {
113 // We have nothing to do. Just chain to the next AliasAnalysis.
114 return AliasAnalysis::getModRefBehavior(CS
);
117 AliasAnalysis::ModRefBehavior
118 ObjCARCAliasAnalysis::getModRefBehavior(const Function
*F
) {
120 return AliasAnalysis::getModRefBehavior(F
);
122 switch (GetFunctionClass(F
)) {
124 return DoesNotAccessMemory
;
129 return AliasAnalysis::getModRefBehavior(F
);
132 AliasAnalysis::ModRefResult
133 ObjCARCAliasAnalysis::getModRefInfo(ImmutableCallSite CS
, const Location
&Loc
) {
135 return AliasAnalysis::getModRefInfo(CS
, Loc
);
137 switch (GetBasicInstructionClass(CS
.getInstruction())) {
141 case IC_AutoreleaseRV
:
143 case IC_AutoreleasepoolPush
:
144 case IC_FusedRetainAutorelease
:
145 case IC_FusedRetainAutoreleaseRV
:
146 // These functions don't access any memory visible to the compiler.
147 // Note that this doesn't include objc_retainBlock, because it updates
148 // pointers when it copies block data.
154 return AliasAnalysis::getModRefInfo(CS
, Loc
);
157 AliasAnalysis::ModRefResult
158 ObjCARCAliasAnalysis::getModRefInfo(ImmutableCallSite CS1
,
159 ImmutableCallSite CS2
) {
160 // TODO: Theoretically we could check for dependencies between objc_* calls
161 // and OnlyAccessesArgumentPointees calls or other well-behaved calls.
162 return AliasAnalysis::getModRefInfo(CS1
, CS2
);