1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
//===--- AliasAnalysis.cpp - SIL Alias Analysis ---------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "sil-aa"
#include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
#include "swift/Basic/Assertions.h"
#include "swift/SIL/SILFunction.h"
#include "swift/SILOptimizer/PassManager/PassManager.h"
#include "llvm/Support/Debug.h"
#include "swift/SILOptimizer/OptimizerBridging.h"
using namespace swift;
// Bridging functions.
static BridgedAliasAnalysis::InitFn initFunction = nullptr;
static BridgedAliasAnalysis::DestroyFn destroyFunction = nullptr;
static BridgedAliasAnalysis::GetMemEffectFn getMemEffectsFunction = nullptr;
static BridgedAliasAnalysis::Escaping2InstFn isObjReleasedFunction = nullptr;
static BridgedAliasAnalysis::Escaping2ValIntFn isAddrVisibleFromObjFunction = nullptr;
static BridgedAliasAnalysis::MayAliasFn mayAliasFunction = nullptr;
void AliasAnalysis::initSwiftSpecificData() {
if (initFunction)
initFunction({this}, sizeof(swiftSpecificData));
}
AliasAnalysis::~AliasAnalysis() {
if (destroyFunction)
destroyFunction({this});
}
bool AliasAnalysis::canApplyDecrementRefCount(FullApplySite FAS, SILValue Ptr) {
// Treat applications of no-return functions as decrementing ref counts. This
// causes the apply to become a sink barrier for ref count increments.
if (FAS.isCalleeNoReturn())
return true;
/// If the pointer cannot escape to the function we are done.
bool result = isObjectReleasedByInst(Ptr, FAS.getInstruction());
return result;
}
bool AliasAnalysis::canBuiltinDecrementRefCount(BuiltinInst *BI, SILValue Ptr) {
return isObjectReleasedByInst(Ptr, BI);
}
namespace {
class AliasAnalysisContainer : public FunctionAnalysisBase<AliasAnalysis> {
SILPassManager *PM = nullptr;
public:
AliasAnalysisContainer() : FunctionAnalysisBase(SILAnalysisKind::Alias) {}
virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {
return K & InvalidationKind::Instructions;
}
virtual void invalidate(SILFunction *f,
SILAnalysis::InvalidationKind k) override {
if (k & InvalidationKind::Effects) {
FunctionAnalysisBase::invalidate();
} else {
FunctionAnalysisBase::invalidate(f, k);
}
}
// Computes loop information for the given function using dominance
// information.
virtual std::unique_ptr<AliasAnalysis>
newFunctionAnalysis(SILFunction *F) override {
assert(PM && "dependent analysis not initialized");
return std::make_unique<AliasAnalysis>(PM);
}
virtual void initialize(SILPassManager *PM) override {
this->PM = PM;
}
};
} // end anonymous namespace
SILAnalysis *swift::createAliasAnalysis(SILModule *M) {
return new AliasAnalysisContainer();
}
//===----------------------------------------------------------------------===//
// Swift Bridging
//===----------------------------------------------------------------------===//
void BridgedAliasAnalysis::registerAnalysis(InitFn initFn,
DestroyFn destroyFn,
GetMemEffectFn getMemEffectsFn,
Escaping2InstFn isObjReleasedFn,
Escaping2ValIntFn isAddrVisibleFromObjFn,
MayAliasFn mayAliasFn) {
initFunction = initFn;
destroyFunction = destroyFn;
getMemEffectsFunction = getMemEffectsFn;
isObjReleasedFunction = isObjReleasedFn;
isAddrVisibleFromObjFunction = isAddrVisibleFromObjFn;
mayAliasFunction = mayAliasFn;
}
MemoryBehavior AliasAnalysis::computeMemoryBehavior(SILInstruction *toInst, SILValue addr) {
if (getMemEffectsFunction) {
return (MemoryBehavior)getMemEffectsFunction({PM->getSwiftPassInvocation()},
{this},
{addr},
{toInst->asSILNode()});
}
return MemoryBehavior::MayHaveSideEffects;
}
bool AliasAnalysis::isObjectReleasedByInst(SILValue obj, SILInstruction *inst) {
if (isObjReleasedFunction) {
return isObjReleasedFunction({PM->getSwiftPassInvocation()}, {this}, {obj}, {inst->asSILNode()});
}
return true;
}
bool AliasAnalysis::isAddrVisibleFromObject(SILValue addr, SILValue obj) {
if (isAddrVisibleFromObjFunction) {
return isAddrVisibleFromObjFunction({PM->getSwiftPassInvocation()}, {this}, {addr}, {obj});
}
return true;
}
bool AliasAnalysis::mayAlias(SILValue lhs, SILValue rhs) {
if (mayAliasFunction) {
return mayAliasFunction({PM->getSwiftPassInvocation()}, {this}, {lhs}, {rhs});
}
return true;
}
|
