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/Function.h"
26 #include "llvm/IR/Instruction.h"
27 #include "llvm/IR/Value.h"
28 #include "llvm/InitializePasses.h"
29 #include "llvm/PassAnalysisSupport.h"
30 #include "llvm/PassSupport.h"
32 #define DEBUG_TYPE "objc-arc-aa"
35 using namespace llvm::objcarc;
37 // Register this pass...
38 char ObjCARCAliasAnalysis::ID = 0;
39 INITIALIZE_AG_PASS(ObjCARCAliasAnalysis, AliasAnalysis, "objc-arc-aa",
40 "ObjC-ARC-Based Alias Analysis", false, true, false)
42 ImmutablePass *llvm::createObjCARCAliasAnalysisPass() {
43 return new ObjCARCAliasAnalysis();
46 bool ObjCARCAliasAnalysis::doInitialization(Module &M) {
47 InitializeAliasAnalysis(this, &M.getDataLayout());
52 ObjCARCAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
54 AliasAnalysis::getAnalysisUsage(AU);
57 AliasResult ObjCARCAliasAnalysis::alias(const MemoryLocation &LocA,
58 const MemoryLocation &LocB) {
60 return AliasAnalysis::alias(LocA, LocB);
62 // First, strip off no-ops, including ObjC-specific no-ops, and try making a
63 // precise alias query.
64 const Value *SA = GetRCIdentityRoot(LocA.Ptr);
65 const Value *SB = GetRCIdentityRoot(LocB.Ptr);
67 AliasAnalysis::alias(MemoryLocation(SA, LocA.Size, LocA.AATags),
68 MemoryLocation(SB, LocB.Size, LocB.AATags));
69 if (Result != MayAlias)
72 // If that failed, climb to the underlying object, including climbing through
73 // ObjC-specific no-ops, and try making an imprecise alias query.
74 const Value *UA = GetUnderlyingObjCPtr(SA, *DL);
75 const Value *UB = GetUnderlyingObjCPtr(SB, *DL);
76 if (UA != SA || UB != SB) {
77 Result = AliasAnalysis::alias(MemoryLocation(UA), MemoryLocation(UB));
78 // We can't use MustAlias or PartialAlias results here because
79 // GetUnderlyingObjCPtr may return an offsetted pointer value.
80 if (Result == NoAlias)
84 // If that failed, fail. We don't need to chain here, since that's covered
85 // by the earlier precise query.
89 bool ObjCARCAliasAnalysis::pointsToConstantMemory(const MemoryLocation &Loc,
92 return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
94 // First, strip off no-ops, including ObjC-specific no-ops, and try making
95 // a precise alias query.
96 const Value *S = GetRCIdentityRoot(Loc.Ptr);
97 if (AliasAnalysis::pointsToConstantMemory(
98 MemoryLocation(S, Loc.Size, Loc.AATags), OrLocal))
101 // If that failed, climb to the underlying object, including climbing through
102 // ObjC-specific no-ops, and try making an imprecise alias query.
103 const Value *U = GetUnderlyingObjCPtr(S, *DL);
105 return AliasAnalysis::pointsToConstantMemory(MemoryLocation(U), OrLocal);
107 // If that failed, fail. We don't need to chain here, since that's covered
108 // by the earlier precise query.
112 FunctionModRefBehavior
113 ObjCARCAliasAnalysis::getModRefBehavior(ImmutableCallSite CS) {
114 // We have nothing to do. Just chain to the next AliasAnalysis.
115 return AliasAnalysis::getModRefBehavior(CS);
118 FunctionModRefBehavior
119 ObjCARCAliasAnalysis::getModRefBehavior(const Function *F) {
121 return AliasAnalysis::getModRefBehavior(F);
123 switch (GetFunctionClass(F)) {
124 case ARCInstKind::NoopCast:
125 return FMRB_DoesNotAccessMemory;
130 return AliasAnalysis::getModRefBehavior(F);
133 ModRefInfo ObjCARCAliasAnalysis::getModRefInfo(ImmutableCallSite CS,
134 const MemoryLocation &Loc) {
136 return AliasAnalysis::getModRefInfo(CS, Loc);
138 switch (GetBasicARCInstKind(CS.getInstruction())) {
139 case ARCInstKind::Retain:
140 case ARCInstKind::RetainRV:
141 case ARCInstKind::Autorelease:
142 case ARCInstKind::AutoreleaseRV:
143 case ARCInstKind::NoopCast:
144 case ARCInstKind::AutoreleasepoolPush:
145 case ARCInstKind::FusedRetainAutorelease:
146 case ARCInstKind::FusedRetainAutoreleaseRV:
147 // These functions don't access any memory visible to the compiler.
148 // Note that this doesn't include objc_retainBlock, because it updates
149 // pointers when it copies block data.
155 return AliasAnalysis::getModRefInfo(CS, Loc);
158 ModRefInfo ObjCARCAliasAnalysis::getModRefInfo(ImmutableCallSite CS1,
159 ImmutableCallSite CS2) {
160 // TODO: Theoretically we could check for dependencies between objc_* calls
161 // and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls.
162 return AliasAnalysis::getModRefInfo(CS1, CS2);