LLVM  15.0.0git
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/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 
38  const MemoryLocation &LocB,
39  AAQueryInfo &AAQI) {
40  if (!EnableARCOpts)
41  return AAResultBase::alias(LocA, LocB, AAQI);
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 =
49  MemoryLocation(SB, LocB.Size, LocB.AATags), AAQI);
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) {
60  // We can't use MustAlias or PartialAlias results here because
61  // GetUnderlyingObjCPtr may return an offsetted pointer value.
62  if (Result == AliasResult::NoAlias)
63  return AliasResult::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 AliasResult::MayAlias;
69 }
70 
72  AAQueryInfo &AAQI, bool OrLocal) {
73  if (!EnableARCOpts)
74  return AAResultBase::pointsToConstantMemory(Loc, AAQI, 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), AAQI, 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);
86  if (U != S)
88  MemoryLocation::getBeforeOrAfter(U), AAQI, 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 
96  if (!EnableARCOpts)
98 
99  switch (GetFunctionClass(F)) {
102  default:
103  break;
104  }
105 
107 }
108 
110  const MemoryLocation &Loc,
111  AAQueryInfo &AAQI) {
112  if (!EnableARCOpts)
113  return AAResultBase::getModRefInfo(Call, Loc, AAQI);
114 
115  switch (GetBasicARCInstKind(Call)) {
116  case ARCInstKind::Retain:
124  // These functions don't access any memory visible to the compiler.
125  // Note that this doesn't include objc_retainBlock, because it updates
126  // pointers when it copies block data.
127  return ModRefInfo::NoModRef;
128  default:
129  break;
130  }
131 
132  return AAResultBase::getModRefInfo(Call, Loc, AAQI);
133 }
134 
135 AnalysisKey ObjCARCAA::Key;
136 
138  return ObjCARCAAResult(F.getParent()->getDataLayout());
139 }
140 
141 char ObjCARCAAWrapperPass::ID = 0;
143  "ObjC-ARC-Based Alias Analysis", false, true)
144 
146  return new ObjCARCAAWrapperPass();
147 }
148 
151 }
152 
154  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
155  return false;
156 }
157 
159  Result.reset();
160  return false;
161 }
162 
164  AU.setPreservesAll();
165 }
llvm::objcarc::GetBasicARCInstKind
ARCInstKind GetBasicARCInstKind(const Value *V)
Determine which objc runtime call instruction class V belongs to.
Definition: ObjCARCInstKind.h:104
llvm::ModRefInfo::NoModRef
@ NoModRef
The access neither references nor modifies the value stored in memory.
llvm::AliasResult::MayAlias
@ MayAlias
The two locations may or may not alias.
Definition: AliasAnalysis.h:102
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:279
llvm::MemoryLocation::Ptr
const Value * Ptr
The address of the start of the location.
Definition: MemoryLocation.h:218
llvm::Function
Definition: Function.h:60
Pass.h
llvm::objcarc::GetFunctionClass
ARCInstKind GetFunctionClass(const Function *F)
Determine if F is one of the special known Functions.
Definition: ObjCARCInstKind.cpp:85
llvm::objcarc::ObjCARCAAResult
This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer querie...
Definition: ObjCARCAliasAnalysis.h:37
llvm::objcarc::ObjCARCAAResult::alias
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI)
Definition: ObjCARCAliasAnalysis.cpp:37
llvm::MemoryLocation::Size
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known.
Definition: MemoryLocation.h:227
llvm::AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:81
llvm::objcarc::ARCInstKind::Autorelease
@ Autorelease
objc_autorelease
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::objcarc::ObjCARCAAWrapperPass::doInitialization
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: ObjCARCAliasAnalysis.cpp:153
llvm::objcarc::ObjCARCAAResult::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const Function *F)
Definition: ObjCARCAliasAnalysis.cpp:95
llvm::objcarc::ObjCARCAAWrapperPass
Legacy wrapper pass to provide the ObjCARCAAResult object.
Definition: ObjCARCAliasAnalysis.h:80
llvm::AAQueryInfo
This class stores info we want to provide to or retain within an alias query.
Definition: AliasAnalysis.h:462
llvm::MemoryLocation::AATags
AAMDNodes AATags
The metadata nodes which describes the aliasing of the location (each member is null if that kind of ...
Definition: MemoryLocation.h:231
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::objcarc::ARCInstKind::RetainRV
@ RetainRV
objc_retainAutoreleasedReturnValue
llvm::objcarc::ARCInstKind::NoopCast
@ NoopCast
objc_retainedObject, etc.
llvm::objcarc::ObjCARCAAResult::getModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
Definition: ObjCARCAliasAnalysis.cpp:109
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
INITIALIZE_PASS
INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa", "ObjC-ARC-Based Alias Analysis", false, true) ImmutablePass *llvm
Definition: ObjCARCAliasAnalysis.cpp:142
llvm::objcarc::ObjCARCAAWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: ObjCARCAliasAnalysis.cpp:163
llvm::AAResultBase::alias
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI)
Definition: AliasAnalysis.h:1222
llvm::objcarc::ARCInstKind::FusedRetainAutorelease
@ FusedRetainAutorelease
objc_retainAutorelease
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
llvm::initializeObjCARCAAWrapperPassPass
void initializeObjCARCAAWrapperPassPass(PassRegistry &)
llvm::createObjCARCAAWrapperPass
ImmutablePass * createObjCARCAAWrapperPass()
llvm::objcarc::ObjCARCAAWrapperPass::doFinalization
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: ObjCARCAliasAnalysis.cpp:158
llvm::ModRefInfo
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: AliasAnalysis.h:148
llvm::objcarc::ObjCARCAAWrapperPass::ObjCARCAAWrapperPass
ObjCARCAAWrapperPass()
Definition: ObjCARCAliasAnalysis.cpp:149
llvm::objcarc::EnableARCOpts
bool EnableARCOpts
A handy option to enable/disable all ARC Optimizations.
Definition: ObjCARCAnalysisUtils.cpp:23
ObjCARCAliasAnalysis.h
llvm::objcarc
Definition: ObjCARCAliasAnalysis.h:29
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::FMRB_DoesNotAccessMemory
@ FMRB_DoesNotAccessMemory
This function does not perform any non-local loads or stores to memory.
Definition: AliasAnalysis.h:268
llvm::AAResultBase::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const CallBase *Call)
Definition: AliasAnalysis.h:1236
llvm::objcarc::ObjCARCAA::run
ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM)
Definition: ObjCARCAliasAnalysis.cpp:137
llvm::objcarc::GetUnderlyingObjCPtr
const Value * GetUnderlyingObjCPtr(const Value *V)
This is a wrapper around getUnderlyingObject which also knows how to look through objc_retain and obj...
Definition: ObjCARCAnalysisUtils.h:69
llvm::AliasResult::NoAlias
@ NoAlias
The two locations do not alias at all.
Definition: AliasAnalysis.h:99
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::FunctionModRefBehavior
FunctionModRefBehavior
Summary of how a function affects memory in the program.
Definition: AliasAnalysis.h:262
llvm::objcarc::GetRCIdentityRoot
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...
Definition: ObjCARCAnalysisUtils.h:110
ObjCARCAnalysisUtils.h
llvm::AAResultBase::getModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
Definition: AliasAnalysis.h:1244
llvm::objcarc::ARCInstKind::AutoreleasepoolPush
@ AutoreleasepoolPush
objc_autoreleasePoolPush
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::objcarc::ARCInstKind::FusedRetainAutoreleaseRV
@ FusedRetainAutoreleaseRV
objc_retainAutoreleaseReturnValue
Function.h
llvm::AAResultBase::pointsToConstantMemory
bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI, bool OrLocal)
Definition: AliasAnalysis.h:1227
llvm::objcarc::ObjCARCAAResult::pointsToConstantMemory
bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI, bool OrLocal)
Definition: ObjCARCAliasAnalysis.cpp:71
llvm::objcarc::ObjCARCAAWrapperPass::ID
static char ID
Definition: ObjCARCAliasAnalysis.h:84
llvm::MemoryLocation::getBeforeOrAfter
static MemoryLocation getBeforeOrAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location before or after Ptr, while remaining within the underl...
Definition: MemoryLocation.h:278
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::objcarc::ARCInstKind::Retain
@ Retain
objc_retain
llvm::MemoryLocation
Representation for a specific memory location.
Definition: MemoryLocation.h:210
Passes.h
llvm::objcarc::ARCInstKind::AutoreleaseRV
@ AutoreleaseRV
objc_autoreleaseReturnValue