LLVM  9.0.0svn
ObjCARCAliasAnalysis.cpp
Go to the documentation of this file.
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 
27 #include "llvm/IR/Function.h"
28 #include "llvm/IR/Instruction.h"
29 #include "llvm/IR/Value.h"
30 #include "llvm/InitializePasses.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 
40  const MemoryLocation &LocB) {
41  if (!EnableARCOpts)
42  return AAResultBase::alias(LocA, LocB);
43 
44  // First, strip off no-ops, including ObjC-specific no-ops, and try making a
45  // precise alias query.
46  const Value *SA = GetRCIdentityRoot(LocA.Ptr);
47  const Value *SB = GetRCIdentityRoot(LocB.Ptr);
48  AliasResult Result =
50  MemoryLocation(SB, LocB.Size, LocB.AATags));
51  if (Result != MayAlias)
52  return Result;
53 
54  // If that failed, climb to the underlying object, including climbing through
55  // ObjC-specific no-ops, and try making an imprecise alias query.
56  const Value *UA = GetUnderlyingObjCPtr(SA, DL);
57  const Value *UB = GetUnderlyingObjCPtr(SB, DL);
58  if (UA != SA || UB != SB) {
60  // We can't use MustAlias or PartialAlias results here because
61  // GetUnderlyingObjCPtr may return an offsetted pointer value.
62  if (Result == NoAlias)
63  return NoAlias;
64  }
65 
66  // If that failed, fail. We don't need to chain here, since that's covered
67  // by the earlier precise query.
68  return MayAlias;
69 }
70 
72  bool OrLocal) {
73  if (!EnableARCOpts)
74  return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
75 
76  // First, strip off no-ops, including ObjC-specific no-ops, and try making
77  // a precise alias query.
78  const Value *S = GetRCIdentityRoot(Loc.Ptr);
80  MemoryLocation(S, Loc.Size, Loc.AATags), OrLocal))
81  return true;
82 
83  // If that failed, climb to the underlying object, including climbing through
84  // ObjC-specific no-ops, and try making an imprecise alias query.
85  const Value *U = GetUnderlyingObjCPtr(S, DL);
86  if (U != S)
88 
89  // If that failed, fail. We don't need to chain here, since that's covered
90  // by the earlier precise query.
91  return false;
92 }
93 
95  if (!EnableARCOpts)
97 
98  switch (GetFunctionClass(F)) {
101  default:
102  break;
103  }
104 
106 }
107 
109  const MemoryLocation &Loc) {
110  if (!EnableARCOpts)
111  return AAResultBase::getModRefInfo(Call, Loc);
112 
113  switch (GetBasicARCInstKind(Call)) {
114  case ARCInstKind::Retain:
122  // These functions don't access any memory visible to the compiler.
123  // Note that this doesn't include objc_retainBlock, because it updates
124  // pointers when it copies block data.
125  return ModRefInfo::NoModRef;
126  default:
127  break;
128  }
129 
130  return AAResultBase::getModRefInfo(Call, Loc);
131 }
132 
134  return ObjCARCAAResult(F.getParent()->getDataLayout());
135 }
136 
137 char ObjCARCAAWrapperPass::ID = 0;
139  "ObjC-ARC-Based Alias Analysis", false, true)
140 
142  return new ObjCARCAAWrapperPass();
143 }
144 
147 }
148 
150  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
151  return false;
152 }
153 
155  Result.reset();
156  return false;
157 }
158 
160  AU.setPreservesAll();
161 }
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal)
The access neither references nor modifies the value stored in memory.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal)
ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM)
objc_retainedObject, etc.
The two locations do not alias at all.
Definition: AliasAnalysis.h:83
FunctionModRefBehavior getModRefBehavior(const CallBase *Call)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1014
F(f)
could call objc_release
objc_autoreleaseReturnValue
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:369
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
objc_retainAutoreleasedReturnValue
FunctionModRefBehavior
Summary of how a function affects memory in the program.
bool EnableARCOpts
A handy option to enable/disable all ARC Optimizations.
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
FunctionModRefBehavior getModRefBehavior(const Function *F)
AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:77
Represent the analysis usage information of a pass.
ARCInstKind GetFunctionClass(const Function *F)
Determine if F is one of the special known Functions.
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...
This file defines common analysis utilities used by the ObjC ARC Optimizer.
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This function does not perform any non-local loads or stores to memory.
ARCInstKind GetBasicARCInstKind(const Value *V)
Determine which objc runtime call instruction class V belongs to.
The two locations may or may not alias. This is the least precise result.
Definition: AliasAnalysis.h:85
const Value * Ptr
The address of the start of the location.
Representation for a specific memory location.
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:255
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
void initializeObjCARCAAWrapperPassPass(PassRegistry &)
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
void setPreservesAll()
Set by analyses that do not transform their input at all.
This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer querie...
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc)
AAMDNodes AATags
The metadata nodes which describes the aliasing of the location (each member is null if that kind of ...
const Value * GetUnderlyingObjCPtr(const Value *V, const DataLayout &DL)
This is a wrapper around getUnderlyingObject which also knows how to look through objc_retain and obj...
ObjCARCAAResult(const DataLayout &DL)
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc)
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:72
Legacy wrapper pass to provide the ObjCARCAAResult object.
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
const Value * GetRCIdentityRoot(const Value *V)
The RCIdentity root of a value V is a dominating value U for which retaining or releasing U is equiva...
A container for analyses that lazily runs them and caches their results.
INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa", "ObjC-ARC-Based Alias Analysis", false, true) ImmutablePass *llvm
ImmutablePass * createObjCARCAAWrapperPass()
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...