39 #include "llvm/ADT/StringRef.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/FileUtilities.h"
42 #include "llvm/Support/InitLLVM.h"
43 #include "llvm/Support/ManagedStatic.h"
44 #include "llvm/Support/Process.h"
45 #include "llvm/Support/Regex.h"
46 #include "llvm/Support/SourceMgr.h"
47 #include "llvm/Support/StringSaver.h"
48 #include "llvm/Support/ThreadPool.h"
49 #include "llvm/Support/ToolOutputFile.h"
55 class BytecodeVersionParser :
public cl::parser<std::optional<int64_t>> {
57 BytecodeVersionParser(cl::Option &o)
58 : cl::parser<std::optional<int64_t>>(o) {}
60 bool parse(cl::Option &o, StringRef , StringRef arg,
61 std::optional<int64_t> &v) {
63 if (getAsSignedInteger(arg, 10, w))
64 return o.error(
"Invalid argument '" + arg +
65 "', only integer is supported.");
74 MlirOptMainConfigCLOptions() {
80 static cl::opt<bool,
true> allowUnregisteredDialects(
81 "allow-unregistered-dialect",
82 cl::desc(
"Allow operation with no registered dialects"),
83 cl::location(allowUnregisteredDialectsFlag), cl::init(
false));
85 static cl::opt<bool,
true> dumpPassPipeline(
86 "dump-pass-pipeline", cl::desc(
"Print the pipeline that will be run"),
87 cl::location(dumpPassPipelineFlag), cl::init(
false));
89 static cl::opt<bool,
true> emitBytecode(
90 "emit-bytecode", cl::desc(
"Emit bytecode when generating output"),
91 cl::location(emitBytecodeFlag), cl::init(
false));
93 static cl::opt<bool,
true> elideResourcesFromBytecode(
94 "elide-resource-data-from-bytecode",
95 cl::desc(
"Elide resources when generating bytecode"),
96 cl::location(elideResourceDataFromBytecodeFlag), cl::init(
false));
98 static cl::opt<std::optional<int64_t>,
true,
99 BytecodeVersionParser>
101 "emit-bytecode-version",
102 cl::desc(
"Use specified bytecode when generating output"),
103 cl::location(emitBytecodeVersion), cl::init(std::nullopt));
105 static cl::opt<std::string,
true> irdlFile(
107 cl::desc(
"IRDL file to register before processing the input"),
108 cl::location(irdlFileFlag), cl::init(
""), cl::value_desc(
"filename"));
110 static cl::opt<bool,
true> enableDebuggerHook(
111 "mlir-enable-debugger-hook",
112 cl::desc(
"Enable Debugger hook for debugging MLIR Actions"),
113 cl::location(enableDebuggerActionHookFlag), cl::init(
false));
115 static cl::opt<bool,
true> explicitModule(
116 "no-implicit-module",
117 cl::desc(
"Disable implicit addition of a top-level module op during "
119 cl::location(useExplicitModuleFlag), cl::init(
false));
121 static cl::opt<bool,
true> runReproducer(
122 "run-reproducer", cl::desc(
"Run the pipeline stored in the reproducer"),
123 cl::location(runReproducerFlag), cl::init(
false));
125 static cl::opt<bool,
true> showDialects(
127 cl::desc(
"Print the list of registered dialects and exit"),
128 cl::location(showDialectsFlag), cl::init(
false));
130 static cl::opt<std::string,
true> splitInputFile{
131 "split-input-file", llvm::cl::ValueOptional,
132 cl::callback([&](
const std::string &str) {
137 cl::desc(
"Split the input file into chunks using the given or "
138 "default marker and process each chunk independently"),
139 cl::location(splitInputFileFlag), cl::init(
"")};
141 static cl::opt<std::string,
true> outputSplitMarker(
142 "output-split-marker",
143 cl::desc(
"Split marker to use for merging the ouput"),
146 static cl::opt<bool,
true> verifyDiagnostics(
147 "verify-diagnostics",
148 cl::desc(
"Check that emitted diagnostics match "
149 "expected-* lines on the corresponding line"),
150 cl::location(verifyDiagnosticsFlag), cl::init(
false));
152 static cl::opt<bool,
true> verifyPasses(
154 cl::desc(
"Run the verifier after each transformation pass"),
155 cl::location(verifyPassesFlag), cl::init(
true));
157 static cl::opt<bool,
true> verifyRoundtrip(
159 cl::desc(
"Round-trip the IR after parsing and ensure it succeeds"),
160 cl::location(verifyRoundtripFlag), cl::init(
false));
162 static cl::list<std::string> passPlugins(
163 "load-pass-plugin", cl::desc(
"Load passes from plugin library"));
165 static cl::opt<std::string,
true>
166 generateReproducerFile(
167 "mlir-generate-reproducer",
169 "Generate an mlir reproducer at the provided filename"
170 " (no crash required)"),
171 cl::location(generateReproducerFileFlag), cl::init(
""),
172 cl::value_desc(
"filename"));
175 passPlugins.setCallback([&](
const std::string &pluginPath) {
178 errs() <<
"Failed to load passes from '" << pluginPath
179 <<
"'. Request ignored.\n";
182 plugin.get().registerPassRegistryCallbacks();
185 static cl::list<std::string> dialectPlugins(
186 "load-dialect-plugin", cl::desc(
"Load dialects from plugin library"));
187 this->dialectPlugins = std::addressof(dialectPlugins);
190 setPassPipelineParser(passPipeline);
198 cl::list<std::string> *dialectPlugins =
nullptr;
217 auto errorHandler = [&](
const Twine &msg) {
223 if (this->shouldDumpPassPipeline()) {
226 llvm::errs() <<
"\n";
233 void MlirOptMainConfigCLOptions::setDialectPluginsCallback(
235 dialectPlugins->setCallback([&](
const std::string &pluginPath) {
238 errs() <<
"Failed to load dialect plugin from '" << pluginPath
239 <<
"'. Request ignored.\n";
242 plugin.get().registerDialectRegistryCallbacks(registry);
248 registry.
insert<irdl::IRDLDialect>();
252 std::string errorMessage;
253 std::unique_ptr<MemoryBuffer> file =
openInputFile(irdlFile, &errorMessage);
262 sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
288 if (!irdlFile.empty() && failed(
loadIRDLDialects(irdlFile, roundtripContext)))
291 std::string testType = (useBytecode) ?
"bytecode" :
"textual";
296 llvm::raw_string_ostream ostream(buffer);
300 <<
"failed to write bytecode, cannot verify round-trip.\n";
309 &fallbackResourceMap);
311 parseSourceString<Operation *>(ostream.str(), parseConfig);
312 if (!roundtripModule) {
313 op->
emitOpError() <<
"failed to parse " << testType
314 <<
" content back, cannot verify round-trip.\n";
321 std::string reference, roundtrip;
323 llvm::raw_string_ostream ostreamref(reference);
324 op->
print(ostreamref,
326 llvm::raw_string_ostream ostreamrndtrip(roundtrip);
327 roundtripModule.
get()->print(
331 if (reference != roundtrip) {
335 <<
" roundTrip testing roundtripped module differs "
336 "from reference:\n<<<<<<Reference\n"
337 << reference <<
"\n=====\n"
338 << roundtrip <<
"\n>>>>>roundtripped\n";
348 return success(succeeded(txtStatus) && succeeded(bcStatus));
359 const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
377 &fallbackResourceMap);
408 if (failed(pm.
run(*op)))
432 <<
"bytecode version while not emitting bytecode";
434 &fallbackResourceMap);
435 op.get()->
print(os, asmState);
443 std::unique_ptr<MemoryBuffer> ownedBuffer,
446 llvm::ThreadPoolInterface *threadPool) {
448 auto sourceMgr = std::make_shared<SourceMgr>();
449 sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
485 return sourceMgrHandler.
verify();
488 std::pair<std::string, std::string>
490 llvm::StringRef toolName,
492 static cl::opt<std::string> inputFilename(
493 cl::Positional, cl::desc(
"<input file>"), cl::init(
"-"));
495 static cl::opt<std::string> outputFilename(
"o", cl::desc(
"Output filename"),
496 cl::value_desc(
"filename"),
507 std::string helpHeader = (toolName +
"\nAvailable Dialects: ").str();
509 llvm::raw_string_ostream os(helpHeader);
511 [&](
auto name) { os << name; });
514 cl::ParseCommandLineOptions(argc, argv, helpHeader);
515 return std::make_pair(inputFilename.getValue(), outputFilename.getValue());
519 llvm::outs() <<
"Available Dialects: ";
521 llvm::outs() <<
"\n";
526 std::unique_ptr<llvm::MemoryBuffer> buffer,
536 ThreadPoolInterface *threadPool =
nullptr;
546 auto chunkFn = [&](std::unique_ptr<MemoryBuffer> chunkBuffer,
548 return processBuffer(os, std::move(chunkBuffer), config, registry,
557 llvm::StringRef inputFilename,
558 llvm::StringRef outputFilename,
561 InitLLVM y(argc, argv);
571 if (inputFilename ==
"-" &&
572 sys::Process::FileDescriptorIsDisplayed(fileno(stdin)))
573 llvm::errs() <<
"(processing input from stdin now, hit ctrl-c/ctrl-d to "
577 std::string errorMessage;
580 llvm::errs() << errorMessage <<
"\n";
586 llvm::errs() << errorMessage <<
"\n";
589 if (failed(
MlirOptMain(output->os(), std::move(file), registry, config)))
601 std::string inputFilename, outputFilename;
602 std::tie(inputFilename, outputFilename) =
605 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)
ManagedStatic< MlirOptMainConfigCLOptions > clOptionsConfig
static LogicalResult processBuffer(raw_ostream &os, std::unique_ptr< MemoryBuffer > ownedBuffer, const MlirOptMainConfig &config, DialectRegistry ®istry, llvm::ThreadPoolInterface *threadPool)
Parses the memory buffer.
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...
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.
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.
tracing::DebugConfig & getDebugConfig()
static MlirOptMainConfig createFromCLOptions()
Create a new config with the default set from the CL options.
bool shouldVerifyPasses() const
StringRef inputSplitMarker() const
bool shouldVerifyRoundtrip() const
std::optional< int64_t > bytecodeVersionToEmit() const
StringRef getReproducerFilename() const
Reproducer file generation (no crash required).
bool shouldShowDialects() const
MlirOptMainConfig & outputSplitMarker(std::string splitMarker=kDefaultSplitMarker)
Set whether to merge the output chunks into one file using the given marker.
bool shouldElideResourceDataFromBytecode() const
bool shouldEmitBytecode() const
LogicalResult setupPassPipeline(PassManager &pm) const
Populate the passmanager, if any callback was set.
static void registerCLOptions(DialectRegistry &dialectRegistry)
Register the options as global LLVM command line options.
bool shouldAllowUnregisteredDialects() const
bool shouldUseExplicitModule() const
bool shouldRunReproducer() const
Return true if the reproducer should be run.
bool shouldVerifyDiagnostics() const
StringRef getIrdlFile() const
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.
Operation is the basic unit of execution within MLIR.
void print(raw_ostream &os, const OpPrintingFlags &flags=std::nullopt)
MLIRContext * getContext()
Return the context this operation is associated with.
OperationName getName()
The name of an operation is the key identifier for it.
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 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...
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...
Include the generated interface declarations.
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.
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.
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.