35 #include "llvm/ADT/StringRef.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/InitLLVM.h"
38 #include "llvm/Support/LogicalResult.h"
39 #include "llvm/Support/ManagedStatic.h"
40 #include "llvm/Support/Process.h"
41 #include "llvm/Support/Regex.h"
42 #include "llvm/Support/SourceMgr.h"
43 #include "llvm/Support/ThreadPool.h"
44 #include "llvm/Support/ToolOutputFile.h"
50 class BytecodeVersionParser :
public cl::parser<std::optional<int64_t>> {
52 BytecodeVersionParser(cl::Option &o)
53 : cl::parser<std::optional<int64_t>>(o) {}
55 bool parse(cl::Option &o, StringRef , StringRef arg,
56 std::optional<int64_t> &v) {
58 if (getAsSignedInteger(arg, 10, w))
59 return o.error(
"Invalid argument '" + arg +
60 "', only integer is supported.");
69 MlirOptMainConfigCLOptions() {
75 static cl::opt<bool,
true> allowUnregisteredDialects(
76 "allow-unregistered-dialect",
77 cl::desc(
"Allow operation with no registered dialects"),
78 cl::location(allowUnregisteredDialectsFlag), cl::init(
false));
80 static cl::opt<bool,
true> dumpPassPipeline(
81 "dump-pass-pipeline", cl::desc(
"Print the pipeline that will be run"),
82 cl::location(dumpPassPipelineFlag), cl::init(
false));
84 static cl::opt<bool,
true> emitBytecode(
85 "emit-bytecode", cl::desc(
"Emit bytecode when generating output"),
86 cl::location(emitBytecodeFlag), cl::init(
false));
88 static cl::opt<bool,
true> elideResourcesFromBytecode(
89 "elide-resource-data-from-bytecode",
90 cl::desc(
"Elide resources when generating bytecode"),
91 cl::location(elideResourceDataFromBytecodeFlag), cl::init(
false));
93 static cl::opt<std::optional<int64_t>,
true,
94 BytecodeVersionParser>
96 "emit-bytecode-version",
97 cl::desc(
"Use specified bytecode when generating output"),
98 cl::location(emitBytecodeVersion), cl::init(std::nullopt));
100 static cl::opt<std::string,
true> irdlFile(
102 cl::desc(
"IRDL file to register before processing the input"),
103 cl::location(irdlFileFlag), cl::init(
""), cl::value_desc(
"filename"));
106 diagnosticVerbosityLevel(
107 "mlir-diagnostic-verbosity-level",
108 cl::desc(
"Choose level of diagnostic information"),
109 cl::location(diagnosticVerbosityLevelFlag),
114 "Errors and warnings"),
116 "Errors, warnings and remarks")));
118 static cl::opt<bool,
true> disableDiagnosticNotes(
119 "mlir-disable-diagnostic-notes", cl::desc(
"Disable diagnostic notes."),
120 cl::location(disableDiagnosticNotesFlag), cl::init(
false));
122 static cl::opt<bool,
true> explicitModule(
123 "no-implicit-module",
124 cl::desc(
"Disable implicit addition of a top-level module op during "
126 cl::location(useExplicitModuleFlag), cl::init(
false));
128 static cl::opt<bool,
true> listPasses(
129 "list-passes", cl::desc(
"Print the list of registered passes and exit"),
130 cl::location(listPassesFlag), cl::init(
false));
132 static cl::opt<bool,
true> runReproducer(
133 "run-reproducer", cl::desc(
"Run the pipeline stored in the reproducer"),
134 cl::location(runReproducerFlag), cl::init(
false));
136 static cl::opt<bool,
true> showDialects(
138 cl::desc(
"Print the list of registered dialects and exit"),
139 cl::location(showDialectsFlag), cl::init(
false));
141 static cl::opt<std::string,
true> splitInputFile{
143 llvm::cl::ValueOptional,
144 cl::callback([&](
const std::string &str) {
149 cl::desc(
"Split the input file into chunks using the given or "
150 "default marker and process each chunk independently"),
151 cl::location(splitInputFileFlag),
154 static cl::opt<std::string,
true> outputSplitMarker(
155 "output-split-marker",
156 cl::desc(
"Split marker to use for merging the ouput"),
162 "verify-diagnostics", llvm::cl::ValueOptional,
163 cl::desc(
"Check that emitted diagnostics match expected-* lines on "
164 "the corresponding line"),
165 cl::location(verifyDiagnosticsFlag),
169 "Check all diagnostics (expected, unexpected, "
174 "Check all diagnostics (expected, unexpected, "
178 "only-expected",
"Check only expected diagnostics"))};
180 static cl::opt<bool,
true> verifyPasses(
182 cl::desc(
"Run the verifier after each transformation pass"),
183 cl::location(verifyPassesFlag), cl::init(
true));
185 static cl::opt<bool,
true> disableVerifyOnParsing(
186 "mlir-very-unsafe-disable-verifier-on-parsing",
187 cl::desc(
"Disable the verifier on parsing (very unsafe)"),
188 cl::location(disableVerifierOnParsingFlag), cl::init(
false));
190 static cl::opt<bool,
true> verifyRoundtrip(
192 cl::desc(
"Round-trip the IR after parsing and ensure it succeeds"),
193 cl::location(verifyRoundtripFlag), cl::init(
false));
195 static cl::list<std::string> passPlugins(
196 "load-pass-plugin", cl::desc(
"Load passes from plugin library"));
198 static cl::opt<std::string,
true>
199 generateReproducerFile(
200 "mlir-generate-reproducer",
202 "Generate an mlir reproducer at the provided filename"
203 " (no crash required)"),
204 cl::location(generateReproducerFileFlag), cl::init(
""),
205 cl::value_desc(
"filename"));
208 passPlugins.setCallback([&](
const std::string &pluginPath) {
211 errs() <<
"Failed to load passes from '" << pluginPath
212 <<
"'. Request ignored.\n";
215 plugin.get().registerPassRegistryCallbacks();
218 static cl::list<std::string> dialectPlugins(
219 "load-dialect-plugin", cl::desc(
"Load dialects from plugin library"));
220 this->dialectPlugins = std::addressof(dialectPlugins);
223 setPassPipelineParser(passPipeline);
231 cl::list<std::string> *dialectPlugins =
nullptr;
239 bool showNotes =
true)
242 auto severity =
diag.getSeverity();
266 llvm_unreachable(
"Unknown diagnostic severity");
287 auto errorHandler = [&](
const Twine &msg) {
293 if (this->shouldDumpPassPipeline()) {
296 llvm::errs() <<
"\n";
303 void MlirOptMainConfigCLOptions::setDialectPluginsCallback(
305 dialectPlugins->setCallback([&](
const std::string &pluginPath) {
308 errs() <<
"Failed to load dialect plugin from '" << pluginPath
309 <<
"'. Request ignored.\n";
312 plugin.get().registerDialectRegistryCallbacks(registry);
318 registry.
insert<irdl::IRDLDialect>();
322 std::string errorMessage;
323 std::unique_ptr<MemoryBuffer> file =
openInputFile(irdlFile, &errorMessage);
332 sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
357 StringRef irdlFile =
config.getIrdlFile();
361 std::string testType = (useBytecode) ?
"bytecode" :
"textual";
366 llvm::raw_string_ostream ostream(buffer);
370 <<
"failed to write bytecode, cannot verify round-trip.\n";
379 &fallbackResourceMap);
380 roundtripModule = parseSourceString<Operation *>(buffer, parseConfig);
381 if (!roundtripModule) {
382 op->
emitOpError() <<
"failed to parse " << testType
383 <<
" content back, cannot verify round-trip.\n";
390 std::string reference, roundtrip;
392 llvm::raw_string_ostream ostreamref(reference);
393 op->
print(ostreamref,
395 llvm::raw_string_ostream ostreamrndtrip(roundtrip);
396 roundtripModule.
get()->print(
400 if (reference != roundtrip) {
404 <<
" roundTrip testing roundtripped module differs "
405 "from reference:\n<<<<<<Reference\n"
406 << reference <<
"\n=====\n"
407 << roundtrip <<
"\n>>>>>roundtripped\n";
417 return success(succeeded(txtStatus) && succeeded(bcStatus));
428 const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
446 &fallbackResourceMap);
447 if (
config.shouldRunReproducer())
453 sourceMgr, parseConfig, !
config.shouldUseExplicitModule());
459 if (
config.shouldVerifyRoundtrip() &&
481 if (!
config.getReproducerFilename().empty()) {
485 config.getReproducerFilename());
490 if (
config.shouldEmitBytecode()) {
492 if (
auto v =
config.bytecodeVersionToEmit())
494 if (
config.shouldElideResourceDataFromBytecode())
499 if (
config.bytecodeVersionToEmit().has_value())
501 <<
"bytecode version while not emitting bytecode";
503 &fallbackResourceMap);
512 llvm::MemoryBufferRef sourceBuffer,
515 llvm::ThreadPoolInterface *threadPool) {
517 auto sourceMgr = std::make_shared<SourceMgr>();
520 sourceMgr->AddNewSourceBuffer(
521 llvm::MemoryBuffer::getMemBuffer(sourceBuffer,
524 sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
534 StringRef irdlFile =
config.getIrdlFile();
540 if (
config.shouldVerifyDiagnostics())
548 if (!
config.shouldVerifyDiagnostics()) {
550 DiagnosticFilter diagnosticFilter(&context,
551 config.getDiagnosticVerbosityLevel(),
552 config.shouldShowNotes());
564 std::pair<std::string, std::string>
566 llvm::StringRef toolName,
568 static cl::opt<std::string> inputFilename(
569 cl::Positional, cl::desc(
"<input file>"), cl::init(
"-"));
571 static cl::opt<std::string> outputFilename(
"o", cl::desc(
"Output filename"),
572 cl::value_desc(
"filename"),
583 std::string helpHeader = (toolName +
"\nAvailable Dialects: ").str();
585 llvm::raw_string_ostream os(helpHeader);
587 [&](
auto name) { os << name; });
590 cl::ParseCommandLineOptions(argc, argv, helpHeader);
591 return std::make_pair(inputFilename.getValue(), outputFilename.getValue());
595 llvm::outs() <<
"Available Dialects: ";
597 llvm::outs() <<
"\n";
607 std::unique_ptr<llvm::MemoryBuffer> buffer,
610 if (
config.shouldShowDialects())
613 if (
config.shouldListPasses())
620 ThreadPoolInterface *threadPool =
nullptr;
631 sourceMgr.AddNewSourceBuffer(
632 llvm::MemoryBuffer::getMemBuffer(buffer->getMemBufferRef(),
639 sourceMgr, &threadPoolCtx,
config.verifyDiagnosticsLevel());
640 auto chunkFn = [&](std::unique_ptr<MemoryBuffer> chunkBuffer,
641 llvm::MemoryBufferRef sourceBuffer, raw_ostream &os) {
643 os, std::move(chunkBuffer), sourceBuffer,
config, registry,
644 config.shouldVerifyDiagnostics() ? &sourceMgrHandler :
nullptr,
648 llvm::MemoryBuffer::getMemBuffer(buffer->getMemBufferRef(),
650 chunkFn, outputStream,
config.inputSplitMarker(),
651 config.outputSplitMarker());
658 llvm::StringRef inputFilename,
659 llvm::StringRef outputFilename,
662 InitLLVM y(argc, argv);
666 if (
config.shouldShowDialects())
669 if (
config.shouldListPasses())
675 if (inputFilename ==
"-" &&
676 sys::Process::FileDescriptorIsDisplayed(fileno(stdin)))
677 llvm::errs() <<
"(processing input from stdin now, hit ctrl-c/ctrl-d to "
681 std::string errorMessage;
684 llvm::errs() << errorMessage <<
"\n";
690 llvm::errs() << errorMessage <<
"\n";
705 std::string inputFilename, outputFilename;
706 std::tie(inputFilename, outputFilename) =
709 return MlirOptMain(argc, argv, inputFilename, outputFilename, registry);
static LogicalResult printRegisteredDialects(DialectRegistry ®istry)
LogicalResult loadIRDLDialects(StringRef irdlFile, MLIRContext &ctx)
static LogicalResult doVerifyRoundTrip(Operation *op, const MlirOptMainConfig &config, bool useBytecode)
static LogicalResult processBuffer(raw_ostream &os, std::unique_ptr< MemoryBuffer > ownedBuffer, llvm::MemoryBufferRef sourceBuffer, const MlirOptMainConfig &config, DialectRegistry ®istry, SourceMgrDiagnosticVerifierHandler *verifyHandler, llvm::ThreadPoolInterface *threadPool)
Parses the memory buffer.
static LogicalResult printRegisteredPassesAndReturn()
ManagedStatic< MlirOptMainConfigCLOptions > clOptionsConfig
static LogicalResult performActions(raw_ostream &os, const std::shared_ptr< llvm::SourceMgr > &sourceMgr, MLIRContext *context, const MlirOptMainConfig &config)
Perform the actions on the input file indicated by the command line flags within the specified contex...
static std::string diag(const llvm::Value &value)
This class provides management for the lifetime of the state used when printing the IR.
This class contains the configuration used for the bytecode writer.
void setElideResourceDataFlag(bool shouldElideResourceData=true)
Set a boolean flag to skip emission of resources into the bytecode file.
void setDesiredBytecodeVersion(int64_t bytecodeVersion)
Set the desired bytecode version to emit.
Facilities for time measurement and report printing to an output stream.
This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine.
static llvm::Expected< DialectPlugin > load(const std::string &filename)
Attempts to load a dialect plugin from a given file.
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
auto getDialectNames() const
Return the names of dialects known to this registry.
A fallback map containing external resources not explicitly handled by another parser/printer.
MLIRContext is the top-level object for a collection of MLIR operations.
void appendDialectRegistry(const DialectRegistry ®istry)
Append the contents of the given dialect registry to the registry associated with this context.
void disableMultithreading(bool disable=true)
Set the flag specifying if multi-threading is disabled by the context.
void setThreadPool(llvm::ThreadPoolInterface &pool)
Set a new thread pool to be used in this context.
void enableMultithreading(bool enable=true)
void printOpOnDiagnostic(bool enable)
Set the flag specifying if we should attach the operation to diagnostics emitted via Operation::emit.
const DialectRegistry & getDialectRegistry()
Return the dialect registry associated with this context.
llvm::ThreadPoolInterface & getThreadPool()
Return the thread pool used by this context.
bool isMultithreadingEnabled()
Return true if multi-threading is enabled by the context.
void allowUnregisteredDialects(bool allow=true)
Enables creating operations in unregistered dialects.
bool allowsUnregisteredDialects()
Return true if we allow to create operation for unregistered dialects.
Configuration options for the mlir-opt tool.
static MlirOptMainConfig createFromCLOptions()
Create a new config with the default set from the CL options.
static void registerCLOptions(DialectRegistry &dialectRegistry)
Register the options as global LLVM command line options.
MlirOptMainConfig & setPassPipelineParser(const PassPipelineCLParser &parser)
Set the parser to use to populate the pass manager.
@ Implicit
Implicit nesting behavior.
iterator_range< pass_iterator > getPasses()
static StringRef getAnyOpAnchorName()
Return the string name used to anchor op-agnostic pass managers that operate generically on any viabl...
Set of flags used to control the behavior of the various IR print methods (e.g.
A wrapper class that allows for printing an operation with a custom AsmState, useful to act as a "str...
Operation is the basic unit of execution within MLIR.
MLIRContext * getContext()
Return the context this operation is associated with.
void print(raw_ostream &os, const OpPrintingFlags &flags={})
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
OpTy get() const
Allow accessing the internal op.
This class represents a configuration for the MLIR assembly parser.
The main pass manager and pipeline builder.
MLIRContext * getContext() const
Return an instance of the context.
LogicalResult run(Operation *op)
Run the passes within this manager on the provided operation.
void enableVerifier(bool enabled=true)
Runs the verifier after each individual pass.
void enableTiming(TimingScope &timingScope)
Add an instrumentation to time the execution of passes and the computation of analyses.
This class implements a command-line parser for MLIR passes.
LogicalResult addToPipeline(OpPassManager &pm, function_ref< LogicalResult(const Twine &)> errorHandler) const
Adds the passes defined by this parser entry to the given pass manager.
static llvm::Expected< PassPlugin > load(const std::string &filename)
Attempts to load a pass plugin from a given file.
This diagnostic handler is a simple RAII class that registers and erases a diagnostic handler on a gi...
This class is a utility diagnostic handler for use with llvm::SourceMgr.
This class is a utility diagnostic handler for use with llvm::SourceMgr that verifies that emitted di...
void registerInContext(MLIRContext *ctx)
Register this handler with the given context.
LogicalResult verify()
Returns the status of the handler and verifies that all expected diagnostics were emitted.
TimingScope getRootScope()
Get the root timer of this timing manager wrapped in a TimingScope for convenience.
An RAII-style wrapper around a timer that ensures the timer is properly started and stopped.
TimingScope nest(Args... args)
Create a nested timing scope.
void stop()
Manually stop the timer early.
static DebugConfig createFromCLOptions()
Create a new config with the default set from the CL options.
static void registerCLOptions()
Register the options as global LLVM command line options.
static void registerCLOptions()
Register the command line options for debug counters.
This is a RAII class that installs the debug handlers on the context based on the provided configurat...
The OpAsmOpInterface, see OpAsmInterface.td for more details.
llvm::LogicalResult loadDialects(ModuleOp op)
Load all the dialects defined in the module.
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Include the generated interface declarations.
std::unique_ptr< llvm::MemoryBuffer > openInputFile(llvm::StringRef inputFilename, std::string *errorMessage=nullptr)
Open the file specified by its name for reading.
LogicalResult applyPassManagerCLOptions(PassManager &pm)
Apply any values provided to the pass manager options that were registered with 'registerPassManagerO...
const char *const kDefaultSplitMarker
void registerDefaultTimingManagerCLOptions()
Register a set of useful command-line options that can be used to configure a DefaultTimingManager.
const FrozenRewritePatternSet GreedyRewriteConfig config
void printRegisteredPasses()
Prints the passes that were previously registered and stored in passRegistry.
LogicalResult MlirOptMain(llvm::raw_ostream &outputStream, std::unique_ptr< llvm::MemoryBuffer > buffer, DialectRegistry ®istry, const MlirOptMainConfig &config)
Perform the core processing behind mlir-opt.
std::unique_ptr< llvm::ToolOutputFile > openOutputFile(llvm::StringRef outputFilename, std::string *errorMessage=nullptr)
Open the file specified by its name for writing.
std::string makeReproducer(StringRef anchorName, const llvm::iterator_range< OpPassManager::pass_iterator > &passes, Operation *op, StringRef outputFile, bool disableThreads=false, bool verifyPasses=false)
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
void registerMLIRContextCLOptions()
Register a set of useful command-line options that can be used to configure various flags within the ...
LogicalResult splitAndProcessBuffer(std::unique_ptr< llvm::MemoryBuffer > originalBuffer, ChunkBufferHandler processChunkBuffer, raw_ostream &os, llvm::StringRef inputSplitMarker=kDefaultSplitMarker, llvm::StringRef outputSplitMarker="")
Splits the specified buffer on a marker (// ----- by default), processes each chunk independently acc...
OwningOpRef< Operation * > parseSourceFileForTool(const std::shared_ptr< llvm::SourceMgr > &sourceMgr, const ParserConfig &config, bool insertImplicitModule)
This parses the file specified by the indicated SourceMgr.
void registerAsmPrinterCLOptions()
Register a set of useful command-line options that can be used to configure various flags within the ...
void registerPassManagerCLOptions()
Register a set of useful command-line options that can be used to configure a pass manager.
void applyDefaultTimingManagerCLOptions(DefaultTimingManager &tm)
Apply any values that were registered with 'registerDefaultTimingManagerOptions' to a DefaultTimingMa...
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
std::pair< std::string, std::string > registerAndParseCLIOptions(int argc, char **argv, llvm::StringRef toolName, DialectRegistry ®istry)
Register and parse command line options.
VerbosityLevel
enum class to indicate the verbosity level of the diagnostic filter.
@ ErrorsWarningsAndRemarks
LogicalResult writeBytecodeToFile(Operation *op, raw_ostream &os, const BytecodeWriterConfig &config={})
Write the bytecode for the given operation to the provided output stream.
void attachResourceParser(ParserConfig &config)
Attach an assembly resource parser to 'config' that collects the MLIR reproducer configuration into t...
LogicalResult apply(PassManager &pm) const
Apply the reproducer options to 'pm' and its context.