1//===- ObjCARCAliasAnalysis.cpp - ObjC ARC Optimization -------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9/// \file
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.
13///
14/// WARNING: This file knows about certain library functions. It recognizes them
15/// by name, and hardwires knowledge of their semantics.
16///
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.
20///
21/// TODO: Theoretically we could check for dependencies between objc_* calls
22/// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls.
23///
24//===----------------------------------------------------------------------===//
25
26#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
27#include "llvm/Analysis/ObjCARCAnalysisUtils.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/PassAnalysisSupport.h"
33#include "llvm/PassSupport.h"
34
35#define DEBUG_TYPE "objc-arc-aa"
36
37using namespace llvm;
38using namespace llvm::objcarc;
39
40AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA,
41                                   const MemoryLocation &LocB) {
42  if (!EnableARCOpts)
43    return AAResultBase::alias(LocA, LocB);
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));
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));
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
72bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
73                                             bool OrLocal) {
74  if (!EnableARCOpts)
75    return AAResultBase::pointsToConstantMemory(Loc, 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), 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), OrLocal);
89
90  // If that failed, fail. We don't need to chain here, since that's covered
91  // by the earlier precise query.
92  return false;
93}
94
95FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
96  if (!EnableARCOpts)
97    return AAResultBase::getModRefBehavior(F);
98
99  switch (GetFunctionClass(F)) {
100  case ARCInstKind::NoopCast:
101    return FMRB_DoesNotAccessMemory;
102  default:
103    break;
104  }
105
106  return AAResultBase::getModRefBehavior(F);
107}
108
109ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS,
110                                          const MemoryLocation &Loc) {
111  if (!EnableARCOpts)
112    return AAResultBase::getModRefInfo(CS, Loc);
113
114  switch (GetBasicARCInstKind(CS.getInstruction())) {
115  case ARCInstKind::Retain:
116  case ARCInstKind::RetainRV:
117  case ARCInstKind::Autorelease:
118  case ARCInstKind::AutoreleaseRV:
119  case ARCInstKind::NoopCast:
120  case ARCInstKind::AutoreleasepoolPush:
121  case ARCInstKind::FusedRetainAutorelease:
122  case ARCInstKind::FusedRetainAutoreleaseRV:
123    // These functions don't access any memory visible to the compiler.
124    // Note that this doesn't include objc_retainBlock, because it updates
125    // pointers when it copies block data.
126    return MRI_NoModRef;
127  default:
128    break;
129  }
130
131  return AAResultBase::getModRefInfo(CS, Loc);
132}
133
134ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> *AM) {
135  return ObjCARCAAResult(F.getParent()->getDataLayout(),
136                         AM->getResult<TargetLibraryAnalysis>(F));
137}
138
139char ObjCARCAA::PassID;
140
141char ObjCARCAAWrapperPass::ID = 0;
142INITIALIZE_PASS_BEGIN(ObjCARCAAWrapperPass, "objc-arc-aa",
143                      "ObjC-ARC-Based Alias Analysis", false, true)
144INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
145INITIALIZE_PASS_END(ObjCARCAAWrapperPass, "objc-arc-aa",
146                    "ObjC-ARC-Based Alias Analysis", false, true)
147
148ImmutablePass *llvm::createObjCARCAAWrapperPass() {
149  return new ObjCARCAAWrapperPass();
150}
151
152ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
153  initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
154}
155
156bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
157  Result.reset(new ObjCARCAAResult(
158      M.getDataLayout(), getAnalysis<TargetLibraryInfoWrapperPass>().getTLI()));
159  return false;
160}
161
162bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
163  Result.reset();
164  return false;
165}
166
167void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
168  AU.setPreservesAll();
169  AU.addRequired<TargetLibraryInfoWrapperPass>();
170}
171