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
|
//===- TransformDialect.cpp - Transform Dialect Definition ----------------===//
//
// 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/Dialect/Transform/IR/TransformDialect.h"
#include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
#include "mlir/Dialect/Transform/IR/TransformOps.h"
#include "mlir/Dialect/Transform/IR/TransformTypes.h"
#include "mlir/IR/DialectImplementation.h"
using namespace mlir;
#include "mlir/Dialect/Transform/IR/TransformDialect.cpp.inc"
#ifndef NDEBUG
void transform::detail::checkImplementsTransformOpInterface(
StringRef name, MLIRContext *context) {
// Since the operation is being inserted into the Transform dialect and the
// dialect does not implement the interface fallback, only check for the op
// itself having the interface implementation.
RegisteredOperationName opName =
*RegisteredOperationName::lookup(name, context);
assert((opName.hasInterface<TransformOpInterface>() ||
opName.hasTrait<OpTrait::IsTerminator>()) &&
"non-terminator ops injected into the transform dialect must "
"implement TransformOpInterface");
assert(opName.hasInterface<MemoryEffectOpInterface>() &&
"ops injected into the transform dialect must implement "
"MemoryEffectsOpInterface");
}
void transform::detail::checkImplementsTransformHandleTypeInterface(
TypeID typeID, MLIRContext *context) {
const auto &abstractType = AbstractType::lookup(typeID, context);
assert(
(abstractType.hasInterface(
TransformHandleTypeInterface::getInterfaceID()) ||
abstractType.hasInterface(
TransformParamTypeInterface::getInterfaceID())) &&
"expected Transform dialect type to implement one of the two interfaces");
}
#endif // NDEBUG
namespace {
struct PDLOperationTypeTransformHandleTypeInterfaceImpl
: public transform::TransformHandleTypeInterface::ExternalModel<
PDLOperationTypeTransformHandleTypeInterfaceImpl,
pdl::OperationType> {
DiagnosedSilenceableFailure
checkPayload(Type type, Location loc, ArrayRef<Operation *> payload) const {
return DiagnosedSilenceableFailure::success();
}
};
} // namespace
void transform::TransformDialect::initialize() {
// Using the checked versions to enable the same assertions as for the ops
// from extensions.
addOperationsChecked<
#define GET_OP_LIST
#include "mlir/Dialect/Transform/IR/TransformOps.cpp.inc"
>();
initializeTypes();
pdl::OperationType::attachInterface<
PDLOperationTypeTransformHandleTypeInterfaceImpl>(*getContext());
}
void transform::TransformDialect::mergeInPDLMatchHooks(
llvm::StringMap<PDLConstraintFunction> &&constraintFns) {
// Steal the constraint functions from the given map.
for (auto &it : constraintFns)
pdlMatchHooks.registerConstraintFunction(it.getKey(), std::move(it.second));
}
const llvm::StringMap<PDLConstraintFunction> &
transform::TransformDialect::getPDLConstraintHooks() const {
return pdlMatchHooks.getConstraintFunctions();
}
Type transform::TransformDialect::parseType(DialectAsmParser &parser) const {
StringRef keyword;
SMLoc loc = parser.getCurrentLocation();
if (failed(parser.parseKeyword(&keyword)))
return nullptr;
auto it = typeParsingHooks.find(keyword);
if (it == typeParsingHooks.end()) {
parser.emitError(loc) << "unknown type mnemonic: " << keyword;
return nullptr;
}
return it->getValue()(parser);
}
void transform::TransformDialect::printType(Type type,
DialectAsmPrinter &printer) const {
auto it = typePrintingHooks.find(type.getTypeID());
assert(it != typePrintingHooks.end() && "printing unknown type");
it->getSecond()(type, printer);
}
void transform::TransformDialect::reportDuplicateTypeRegistration(
StringRef mnemonic) {
std::string buffer;
llvm::raw_string_ostream msg(buffer);
msg << "extensible dialect type '" << mnemonic
<< "' is already registered with a different implementation";
msg.flush();
llvm::report_fatal_error(StringRef(buffer));
}
void transform::TransformDialect::reportDuplicateOpRegistration(
StringRef opName) {
std::string buffer;
llvm::raw_string_ostream msg(buffer);
msg << "extensible dialect operation '" << opName
<< "' is already registered with a mismatching TypeID";
msg.flush();
llvm::report_fatal_error(StringRef(buffer));
}
#include "mlir/Dialect/Transform/IR/TransformDialectEnums.cpp.inc"
|
