blob: 1382060f4dd9027592956a381e10a03e549f638e (
plain)
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
|
//===- AliasAnalysis.cpp - Alias Analysis for MLIR ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "mlir/Analysis/AliasAnalysis.h"
#include "mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h"
#include "mlir/IR/Operation.h"
#include "mlir/IR/Value.h"
#include "mlir/Support/LLVM.h"
#include <memory>
using namespace mlir;
//===----------------------------------------------------------------------===//
// AliasResult
//===----------------------------------------------------------------------===//
/// Merge this alias result with `other` and return a new result that
/// represents the conservative merge of both results.
AliasResult AliasResult::merge(AliasResult other) const {
if (kind == other.kind)
return *this;
// A mix of PartialAlias and MustAlias is PartialAlias.
if ((isPartial() && other.isMust()) || (other.isPartial() && isMust()))
return PartialAlias;
// Otherwise, don't assume anything.
return MayAlias;
}
void AliasResult::print(raw_ostream &os) const {
switch (kind) {
case Kind::NoAlias:
os << "NoAlias";
break;
case Kind::MayAlias:
os << "MayAlias";
break;
case Kind::PartialAlias:
os << "PartialAlias";
break;
case Kind::MustAlias:
os << "MustAlias";
break;
}
}
//===----------------------------------------------------------------------===//
// ModRefResult
//===----------------------------------------------------------------------===//
void ModRefResult::print(raw_ostream &os) const {
switch (kind) {
case Kind::NoModRef:
os << "NoModRef";
break;
case Kind::Ref:
os << "Ref";
break;
case Kind::Mod:
os << "Mod";
break;
case Kind::ModRef:
os << "ModRef";
break;
}
}
//===----------------------------------------------------------------------===//
// AliasAnalysis
//===----------------------------------------------------------------------===//
AliasAnalysis::AliasAnalysis(Operation *op) {
addAnalysisImplementation(LocalAliasAnalysis());
}
AliasResult AliasAnalysis::alias(Value lhs, Value rhs) {
// Check each of the alias analysis implemenations for an alias result.
for (const std::unique_ptr<Concept> &aliasImpl : aliasImpls) {
AliasResult result = aliasImpl->alias(lhs, rhs);
if (!result.isMay())
return result;
}
return AliasResult::MayAlias;
}
ModRefResult AliasAnalysis::getModRef(Operation *op, Value location) {
// Compute the mod-ref behavior by refining a top `ModRef` result with each of
// the alias analysis implementations. We early exit at the point where we
// refine down to a `NoModRef`.
ModRefResult result = ModRefResult::getModAndRef();
for (const std::unique_ptr<Concept> &aliasImpl : aliasImpls) {
result = result.intersect(aliasImpl->getModRef(op, location));
if (result.isNoModRef())
return result;
}
return result;
}
|
