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
144
145
146
|
//===- Constraint.cpp - Constraint class ----------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Constraint wrapper to simplify using TableGen Record for constraints.
//
//===----------------------------------------------------------------------===//
#include "mlir/TableGen/Constraint.h"
#include "llvm/TableGen/Record.h"
using namespace mlir;
using namespace mlir::tblgen;
Constraint::Constraint(const llvm::Record *record)
: Constraint(record, CK_Uncategorized) {
// Look through OpVariable's to their constraint.
if (def->isSubClassOf("OpVariable"))
def = def->getValueAsDef("constraint");
if (def->isSubClassOf("TypeConstraint")) {
kind = CK_Type;
} else if (def->isSubClassOf("AttrConstraint")) {
kind = CK_Attr;
} else if (def->isSubClassOf("RegionConstraint")) {
kind = CK_Region;
} else if (def->isSubClassOf("SuccessorConstraint")) {
kind = CK_Successor;
} else {
assert(def->isSubClassOf("Constraint"));
}
}
Pred Constraint::getPredicate() const {
auto *val = def->getValue("predicate");
// If no predicate is specified, then return the null predicate (which
// corresponds to true).
if (!val)
return Pred();
const auto *pred = dyn_cast<llvm::DefInit>(val->getValue());
return Pred(pred);
}
std::string Constraint::getConditionTemplate() const {
return getPredicate().getCondition();
}
StringRef Constraint::getSummary() const {
if (std::optional<StringRef> summary =
def->getValueAsOptionalString("summary"))
return *summary;
return def->getName();
}
StringRef Constraint::getDescription() const {
return def->getValueAsOptionalString("description").value_or("");
}
StringRef Constraint::getDefName() const {
if (std::optional<StringRef> baseDefName = getBaseDefName())
return *baseDefName;
return def->getName();
}
std::string Constraint::getUniqueDefName() const {
std::string defName = def->getName().str();
// Non-anonymous classes already have a unique name from the def.
if (!def->isAnonymous())
return defName;
// Otherwise, this is an anonymous class. In these cases we still use the def
// name, but we also try attach the name of the base def when present to make
// the name more obvious.
if (std::optional<StringRef> baseDefName = getBaseDefName())
return (*baseDefName + "(" + defName + ")").str();
return defName;
}
std::optional<StringRef> Constraint::getBaseDefName() const {
// Functor used to check a base def in the case where the current def is
// anonymous.
auto checkBaseDefFn = [&](StringRef baseName) -> std::optional<StringRef> {
if (const auto *defValue = def->getValue(baseName)) {
if (const auto *defInit = dyn_cast<llvm::DefInit>(defValue->getValue()))
return Constraint(defInit->getDef(), kind).getDefName();
}
return std::nullopt;
};
switch (kind) {
case CK_Attr:
if (def->isAnonymous())
return checkBaseDefFn("baseAttr");
return std::nullopt;
case CK_Type:
if (def->isAnonymous())
return checkBaseDefFn("baseType");
return std::nullopt;
default:
return std::nullopt;
}
}
AppliedConstraint::AppliedConstraint(Constraint &&constraint,
llvm::StringRef self,
std::vector<std::string> &&entities)
: constraint(constraint), self(std::string(self)),
entities(std::move(entities)) {}
Constraint DenseMapInfo<Constraint>::getEmptyKey() {
return Constraint(RecordDenseMapInfo::getEmptyKey(),
Constraint::CK_Uncategorized);
}
Constraint DenseMapInfo<Constraint>::getTombstoneKey() {
return Constraint(RecordDenseMapInfo::getTombstoneKey(),
Constraint::CK_Uncategorized);
}
unsigned DenseMapInfo<Constraint>::getHashValue(Constraint constraint) {
if (constraint == getEmptyKey())
return RecordDenseMapInfo::getHashValue(RecordDenseMapInfo::getEmptyKey());
if (constraint == getTombstoneKey()) {
return RecordDenseMapInfo::getHashValue(
RecordDenseMapInfo::getTombstoneKey());
}
return llvm::hash_combine(constraint.getPredicate(), constraint.getSummary());
}
bool DenseMapInfo<Constraint>::isEqual(Constraint lhs, Constraint rhs) {
if (lhs == rhs)
return true;
if (lhs == getEmptyKey() || lhs == getTombstoneKey())
return false;
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
return false;
return lhs.getPredicate() == rhs.getPredicate() &&
lhs.getSummary() == rhs.getSummary();
}
|
