LLVM 20.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/// TODO: The calls here to AAResultBase member functions are all effectively
24/// no-ops that just return a conservative result. The original intent was to
25/// chain to another analysis for a recursive query, but this was lost in a
26/// refactor. These should instead be rephrased in terms of queries to AAQI.AAR.
27///
28//===----------------------------------------------------------------------===//
29
32#include "llvm/IR/Function.h"
33#include "llvm/Pass.h"
34
35#define DEBUG_TYPE "objc-arc-aa"
36
37using namespace llvm;
38using namespace llvm::objcarc;
39
41 const MemoryLocation &LocB,
42 AAQueryInfo &AAQI, const Instruction *) {
43 if (!EnableARCOpts)
44 return AAResultBase::alias(LocA, LocB, AAQI, nullptr);
45
46 // First, strip off no-ops, including ObjC-specific no-ops, and try making a
47 // precise alias query.
48 const Value *SA = GetRCIdentityRoot(LocA.Ptr);
49 const Value *SB = GetRCIdentityRoot(LocB.Ptr);
51 MemoryLocation(SA, LocA.Size, LocA.AATags),
52 MemoryLocation(SB, LocB.Size, LocB.AATags), AAQI, nullptr);
53 if (Result != AliasResult::MayAlias)
54 return Result;
55
56 // If that failed, climb to the underlying object, including climbing through
57 // ObjC-specific no-ops, and try making an imprecise alias query.
58 const Value *UA = GetUnderlyingObjCPtr(SA);
59 const Value *UB = GetUnderlyingObjCPtr(SB);
60 if (UA != SA || UB != SB) {
63 nullptr);
64 // We can't use MustAlias or PartialAlias results here because
65 // GetUnderlyingObjCPtr may return an offsetted pointer value.
66 if (Result == AliasResult::NoAlias)
68 }
69
70 // If that failed, fail. We don't need to chain here, since that's covered
71 // by the earlier precise query.
73}
74
76 AAQueryInfo &AAQI,
77 bool IgnoreLocals) {
78 if (!EnableARCOpts)
79 return AAResultBase::getModRefInfoMask(Loc, AAQI, IgnoreLocals);
80
81 // First, strip off no-ops, including ObjC-specific no-ops, and try making
82 // a precise alias query.
83 const Value *S = GetRCIdentityRoot(Loc.Ptr);
85 MemoryLocation(S, Loc.Size, Loc.AATags), AAQI, IgnoreLocals)))
87
88 // If that failed, climb to the underlying object, including climbing through
89 // ObjC-specific no-ops, and try making an imprecise alias query.
90 const Value *U = GetUnderlyingObjCPtr(S);
91 if (U != S)
93 AAQI, IgnoreLocals);
94
95 // If that failed, fail. We don't need to chain here, since that's covered
96 // by the earlier precise query.
97 return ModRefInfo::ModRef;
98}
99
101 if (!EnableARCOpts)
103
104 switch (GetFunctionClass(F)) {
106 return MemoryEffects::none();
107 default:
108 break;
109 }
110
112}
113
115 const MemoryLocation &Loc,
116 AAQueryInfo &AAQI) {
117 if (!EnableARCOpts)
118 return AAResultBase::getModRefInfo(Call, Loc, AAQI);
119
120 switch (GetBasicARCInstKind(Call)) {
129 // These functions don't access any memory visible to the compiler.
130 // Note that this doesn't include objc_retainBlock, because it updates
131 // pointers when it copies block data.
133 default:
134 break;
135 }
136
137 return AAResultBase::getModRefInfo(Call, Loc, AAQI);
138}
139
140AnalysisKey ObjCARCAA::Key;
141
143 return ObjCARCAAResult(F.getDataLayout());
144}
#define F(x, y, z)
Definition: MD5.cpp:55
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This file defines common analysis utilities used by the ObjC ARC Optimizer.
This class stores info we want to provide to or retain within an alias query.
MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI)
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI, bool IgnoreLocals)
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI, const Instruction *I)
The possible results of an alias query.
Definition: AliasAnalysis.h:77
@ MayAlias
The two locations may or may not alias.
Definition: AliasAnalysis.h:98
@ NoAlias
The two locations do not alias at all.
Definition: AliasAnalysis.h:95
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1120
static MemoryEffectsBase none()
Create MemoryEffectsBase that cannot read or write any memory.
Definition: ModRef.h:117
Representation for a specific memory location.
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known.
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...
AAMDNodes AATags
The metadata nodes which describes the aliasing of the location (each member is null if that kind of ...
const Value * Ptr
The address of the start of the location.
LLVM Value Representation.
Definition: Value.h:74
This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer querie...
MemoryEffects getMemoryEffects(const Function *F)
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI, bool IgnoreLocals)
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI, const Instruction *CtxI)
ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM)
@ FusedRetainAutorelease
objc_retainAutorelease
@ AutoreleasepoolPush
objc_autoreleasePoolPush
@ Autorelease
objc_autorelease
@ RetainRV
objc_retainAutoreleasedReturnValue
@ FusedRetainAutoreleaseRV
objc_retainAutoreleaseReturnValue
@ AutoreleaseRV
objc_autoreleaseReturnValue
@ Call
could call objc_release
@ NoopCast
objc_retainedObject, etc.
ARCInstKind GetFunctionClass(const Function *F)
Determine if F is one of the special known Functions.
bool EnableARCOpts
A handy option to enable/disable all ARC Optimizations.
ARCInstKind GetBasicARCInstKind(const Value *V)
Determine which objc runtime call instruction class V belongs to.
const Value * GetUnderlyingObjCPtr(const Value *V)
This is a wrapper around getUnderlyingObject which also knows how to look through objc_retain and obj...
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...
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: ModRef.h:27
@ ModRef
The access may reference and may modify the value stored in memory.
@ NoModRef
The access neither references nor modifies the value stored in memory.
bool isNoModRef(const ModRefInfo MRI)
Definition: ModRef.h:39
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:28