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
|
//===- mlir-irdl-to-cpp.cpp - IRDL to C++ conversion tool -----------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This is a command line utility that translates an IRDL dialect definition
// into a C++ implementation to be included in MLIR.
//
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/IRDL/IR/IRDL.h"
#include "mlir/IR/AsmState.h"
#include "mlir/IR/DialectRegistry.h"
#include "mlir/IR/MLIRContext.h"
#include "mlir/Support/FileUtilities.h"
#include "mlir/Support/ToolUtilities.h"
#include "mlir/Target/IRDLToCpp/IRDLToCpp.h"
#include "mlir/Tools/ParseUtilities.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/InitLLVM.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/ToolOutputFile.h"
using namespace mlir;
static LogicalResult
processBuffer(llvm::raw_ostream &os,
std::unique_ptr<llvm::MemoryBuffer> ownedBuffer,
bool verifyDiagnostics, llvm::ThreadPoolInterface *threadPool) {
// Tell sourceMgr about this buffer, which is what the parser will pick up.
auto sourceMgr = std::make_shared<llvm::SourceMgr>();
sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
DialectRegistry registry;
registry.insert<irdl::IRDLDialect>();
MLIRContext ctx(registry);
ctx.printOpOnDiagnostic(!verifyDiagnostics);
auto runTranslation = [&]() {
ParserConfig parseConfig(&ctx);
OwningOpRef<Operation *> op =
parseSourceFileForTool(sourceMgr, parseConfig, true);
if (!op)
return failure();
auto moduleOp = llvm::cast<ModuleOp>(*op);
llvm::SmallVector<irdl::DialectOp> dialects{
moduleOp.getOps<irdl::DialectOp>(),
};
return irdl::translateIRDLDialectToCpp(dialects, os);
};
if (!verifyDiagnostics) {
// If no errors are expected, return translation result.
SourceMgrDiagnosticHandler srcManagerHandler(*sourceMgr, &ctx);
return runTranslation();
}
// If errors are expected, ignore translation result and check for
// diagnostics.
SourceMgrDiagnosticVerifierHandler srcManagerHandler(*sourceMgr, &ctx);
(void)runTranslation();
return srcManagerHandler.verify();
}
static LogicalResult translateIRDLToCpp(int argc, char **argv) {
static llvm::cl::opt<std::string> inputFilename(
llvm::cl::Positional, llvm::cl::desc("<input file>"),
llvm::cl::init("-"));
static llvm::cl::opt<std::string> outputFilename(
"o", llvm::cl::desc("Output filename"), llvm::cl::value_desc("filename"),
llvm::cl::init("-"));
static llvm::cl::opt<bool> verifyDiagnostics(
"verify-diagnostics",
llvm::cl::desc("Check that emitted diagnostics match "
"expected-* lines on the corresponding line"),
llvm::cl::init(false));
static llvm::cl::opt<std::string> splitInputFile(
"split-input-file", llvm::cl::ValueOptional,
llvm::cl::callback([&](const std::string &str) {
// Implicit value: use default marker if flag was used without
// value.
if (str.empty())
splitInputFile.setValue(kDefaultSplitMarker);
}),
llvm::cl::desc("Split the input file into chunks using the given or "
"default marker and process each chunk independently"),
llvm::cl::init(""));
llvm::InitLLVM y(argc, argv);
llvm::cl::ParseCommandLineOptions(argc, argv, "mlir-irdl-to-cpp");
std::string errorMessage;
std::unique_ptr<llvm::MemoryBuffer> input =
openInputFile(inputFilename, &errorMessage);
if (!input) {
llvm::errs() << errorMessage << "\n";
return failure();
}
std::unique_ptr<llvm::ToolOutputFile> output =
openOutputFile(outputFilename, &errorMessage);
if (!output) {
llvm::errs() << errorMessage << "\n";
return failure();
}
auto chunkFn = [&](std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
raw_ostream &os) {
return processBuffer(output->os(), std::move(chunkBuffer),
verifyDiagnostics, nullptr);
};
auto &splitInputFileDelimiter = splitInputFile.getValue();
if (splitInputFileDelimiter.size())
return splitAndProcessBuffer(std::move(input), chunkFn, output->os(),
splitInputFileDelimiter,
splitInputFileDelimiter);
if (failed(chunkFn(std::move(input), output->os())))
return failure();
if (!verifyDiagnostics)
output->keep();
return success();
}
int main(int argc, char **argv) {
return failed(translateIRDLToCpp(argc, argv));
}
|
