[mlir-opt] Support parsing operations other than 'builtin.module' as top-level

[rkayaith]

Summary

This adds a --no-implicit-module option, which disables the insertion
of a top-level builtin.module during parsing. In this mode any op may
be top-level, however it's required that there be exactly one top-level
op in the source.

parseSource{File,String} now support Operation * as the container op
type, which disables the top-level-op-insertion behaviour.

Following patches will add the same option to the other tools as well.

Depends on D133644

[rkayaith]

new approach: option to disable all parser magic and allow any op to be top-level

[rkayaith]

update description

[rkayaith]

misc changes

[rriddle]

mlir/include/mlir/Parser/Parser.h

130–157

Can you just SFINAE the templated parseSourceFile below and handle Operation * separately from other ContainerOpT?

mlir/lib/Parser/Parser.cpp

133–147 ↗

(On Diff #461407)

It'd be nice not to have these in the Parser lib, and instead somewhere else. Taking a step back though, is this really worth sharing? as opposed to having this be added only in the necessary places?

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

83

This isn't correct, not all operations can be used with a pass manager. You'll have to check if the op is isolated from above or not.

[rkayaith]

address comments

[rkayaith]

mlir/include/mlir/Parser/Parser.h

130–157

I changed detail::constructContainerOpForParserIfNecessary instead of detail::parseSourceFile since it's used by parseSourceString, is this sort of what you had in mind? The new overloads aren't strictly necessary now, but keeping them separate means they get simpler doc strings. I'm also hoping we can eventually deprecate the templated overloads and move the top-level-op-creation logic into the tools instead.

mlir/lib/Parser/Parser.cpp

133–147 ↗

(On Diff #461407)

Originally I had this duplicated in each tool, but sharing it helped keep things in sync across tools when iterating. Duplicating it now wouldn't be too bad, though I have a slight preference to sharing since it encourages tools to have consistent parsing behaviour.

Definitely agreed this seems like the wrong place though, I wasn't sure where to put it.

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

83

the pass manager actually checks this already, added a test demonstrating that

[bondhugula]

mlir/lib/Parser/Parser.cpp

79 ↗

(On Diff #461634)

This description doesn't appear accurate. Instead:
Disable implicit addition of a top-level module op during parsing?

87–88 ↗

(On Diff #461634)

I'm not sure this is user-friendly. Instead, asserting with a message will help.

mlir/test/IR/top-level.mlir

4–5

CHECK-NEXT: func.func is enough?

[rkayaith]

improve option description

[rkayaith]

mlir/lib/Parser/Parser.cpp

87–88 ↗

(On Diff #461634)

This is just following a pattern I saw elsewhere for avoiding a global constructor for the options, e.g. https://github.com/llvm/llvm-project/blob/04df971d65a769d7c03fa69c01a4d302169fdc72/mlir/lib/IR/MLIRContext.cpp#L86-L89

There's an assert below in parseSourceFileForTool though, that'll get hit if a user forgets to call registerToolParserCLOptions

mlir/test/IR/top-level.mlir

4–5

tried that out but I get error: found 'CHECK-NEXT' without previous 'CHECK: line

[mehdi_amini]

mlir/lib/Parser/Parser.cpp

85 ↗

(On Diff #461669)

Can we avoid handling this as a global?

I rather have the Parser expose an API (ParserConfig) and push the option to CLI tools as needed.

I know MLIRContext does that, but I would not want it done this way today...

[rkayaith]

mlir/lib/Parser/Parser.cpp

85 ↗

(On Diff #461669)

I was thinking to keep this out of the core parser API, and instead move the global + parseSourceFileForTool somewhere under lib/Tools (or if it's not worth sharing, just duplicate it in all tools like River mentioned ).

But if it's preferable to add it to ParserConfig I can do that instead. I'm not sure how to support the existing parse functions that way though, since they take the top level op as a template arg.

[rkayaith]

• move implicit-module logic into AsmParser, controlled by new option on ParserConfig
• remove shared cl option

[rkayaith]

I switched to having the implicit module be controlled by an option on ParserConfig, but now there's two places that are adding implicit top-level ops:

• in the asm parser, controlled by the ParserConfig, which only supports inserting builtin.module
• in parseSource{File,String}<ContainerOpT>, which supports inserting other operations

Are there any objections to deprecating the templated overloads in favour of using the ParserConfig option?

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1419–1421 ↗

(On Diff #462034)

it doesn't seem worth supporting this for bytecode, and I'm not sure how I would test it anyways

mlir/lib/Parser/Parser.cpp

85 ↗

(On Diff #461669)

Thinking about this some more, if we want to expose this as an option to the python/C bindings then it seems better to just have it as on option on ParserConfig. In the latest diff I switched to that approach and got rid of the global option.

133–147 ↗

(On Diff #461407)

I got rid of the shared options in the latest revision

[rriddle]

The config option feels like a regression to me. It is now baking builtin.module into places that didn't require it before. I still think this is something that should be left to tools that actually want the implicit module wrapping.

For the templated version of parseSourceFile, I think the ideal end state for those would remove the implicit wrapping and leave that to a different method (just emitting an error if the parsed IR wasn't a single operation of the expected type).

[rkayaith]

In D133645#3807239, @rriddle wrote:

The config option feels like a regression to me. It is now baking builtin.module into places that didn't require it before. I still think this is something that should be left to tools that actually want the implicit module wrapping.

For the templated version of parseSourceFile, I think the ideal end state for those would remove the implicit wrapping and leave that to a different method (just emitting an error if the parsed IR wasn't a single operation of the expected type).

hm okay, then how about adding OwningOpRef<Operation *> parseSourceFileForTool(SourceMgr &sourceMgr, bool insertImplicitModule) to mlir/Support/ToolUtilities.h, and eventually moving the implicit wrapping out of Parser.h and into there?

[rkayaith]

remove option from ParserConfig, replace with parseSourceFileForTool utility

[rriddle]

LGTM after addressing the comments.

mlir/include/mlir/Parser/Parser.h

208

Do we need new parse methods for these? I think the direction we should likely head in is having parseSourceFile disallow implicit wrapping, and then introduce new parseSourceFileAndWrap methods that wrap the parsed IR if necessary. For example, calling parseSourceFile<ModuleOp> would error if the IR doesn't contain a single ModuleOp, whereas parseSourceFileAndWrap<ModuleOp> would implicitly wrap the IR with a module if necessary (i.e. the current behavior). That would make the behavior during parsing a bit more self-consistent and less surprising.

mlir/include/mlir/Tools/ParseUtilties.h

30–34

[rkayaith]

mlir/include/mlir/Parser/Parser.h

208

What I was planning was to just deprecate parseSourceFile<ContainerOp> entirely and move upstream users to either the new parse methods, or parseSourceFileForTool if they want the wrapping. That way there's a nice warning for downstreams, and the wrapping is kept out of the "core" api here. What you described seems fine too though, I can get rid of these new methods if we want to go with that.

[rriddle]

mlir/include/mlir/Parser/Parser.h

208

We shouldn't force all parsing to be through a generic Operation *. Many use cases want to make assumptions about what the top level IR is supposed to be, so we should still accommodate those situations. The behavior we should make more explicit though, is the implicit nesting.

[rkayaith]

address comments

[rkayaith]

reset author info to make the buildbot happy?

mlir/include/mlir/IR/OwningOpRef.h

 /// instead, and this should only be used in situations where existing solutions
 /// are not viable.
 template <typename OpTy>
 class OwningOpRef {
 public:
   /// The underlying operation type stored in this reference.
   using OperationT = OpTy;
 
-  OwningOpRef(std::nullptr_t = nullptr) {}
+  OwningOpRef(std::nullptr_t = nullptr) : op(nullptr) {}
   OwningOpRef(OpTy op) : op(op) {}
   OwningOpRef(OwningOpRef &&other) : op(other.release()) {}
   ~OwningOpRef() {
     if (op)
       op->erase();
   }
 
   /// Assign from another op reference.
   OwningOpRef &operator=(OwningOpRef &&other) {
     if (op)
       op->erase();
     op = other.release();
     return *this;
   }
 
   /// Allow accessing the internal op.
   OpTy get() const { return op; }
   OpTy operator*() const { return op; }
   OpTy *operator->() { return &op; }
   explicit operator bool() const { return op; }
 
   /// Release the referenced op.
   OpTy release() {
-    OpTy released;
+    OpTy released(nullptr);
     std::swap(released, op);
     return released;
   }
 
 private:
   OpTy op;
 };
 
 } // namespace mlir
 
 #endif // MLIR_IR_OWNINGOPREF_H

mlir/include/mlir/Parser/Parser.h

 /// block and return it. If the block does not contain just that operation,
 /// create a new operation instance of `ContainerOpT` and move all of the
 /// operations within `parsedBlock` into the first block of the first region.
 /// `ContainerOpT` is required to have a single region containing a single
 /// block, and must implement the `SingleBlockImplicitTerminator` trait.
 template <typename ContainerOpT>
 inline OwningOpRef<ContainerOpT> constructContainerOpForParserIfNecessary(
     Block *parsedBlock, MLIRContext *context, Location sourceFileLoc) {
-  static_assert(
-      ContainerOpT::template hasTrait<OpTrait::OneRegion>() &&
-          (ContainerOpT::template hasTrait<OpTrait::NoTerminator>() ||
-           OpTrait::template hasSingleBlockImplicitTerminator<
-               ContainerOpT>::value),
-      "Expected `ContainerOpT` to have a single region with a single "
-      "block that has an implicit terminator or does not require one");
 
   // Check to see if we parsed a single instance of this operation.
   if (llvm::hasSingleElement(*parsedBlock)) {
-    if (ContainerOpT op = dyn_cast<ContainerOpT>(parsedBlock->front())) {
+    if (ContainerOpT op = dyn_cast<ContainerOpT>(&parsedBlock->front())) {
       op->remove();
       return op;
     }
   }
 
-  // If not, then build a new one to contain the parsed operations.
+  // If not, then build a new top-level op if a concrete operation type was
+  // specified.
+  if constexpr (std::is_same_v<ContainerOpT, Operation *>) {
+    return emitError(sourceFileLoc)
+               << "source must contain a single top-level operation, found: "
+               << parsedBlock->getOperations().size(),
+           nullptr;
+  } else {
+    static_assert(
+        ContainerOpT::template hasTrait<OpTrait::OneRegion>() &&
+            (ContainerOpT::template hasTrait<OpTrait::NoTerminator>() ||
+             OpTrait::template hasSingleBlockImplicitTerminator<
+                 ContainerOpT>::value),
+        "Expected `ContainerOpT` to have a single region with a single "
+        "block that has an implicit terminator or does not require one");
+
     OpBuilder builder(context);
     ContainerOpT op = builder.create<ContainerOpT>(sourceFileLoc);
     OwningOpRef<ContainerOpT> opRef(op);
-  assert(op->getNumRegions() == 1 && llvm::hasSingleElement(op->getRegion(0)) &&
+    assert(op->getNumRegions() == 1 &&
+           llvm::hasSingleElement(op->getRegion(0)) &&
            "expected generated operation to have a single region with a single "
            "block");
     Block *opBlock = &op->getRegion(0).front();
     opBlock->getOperations().splice(opBlock->begin(),
                                     parsedBlock->getOperations());
 
     // After splicing, verify just this operation to ensure it can properly
     // contain the operations inside of it.
     if (failed(op.verifyInvariants()))
       return OwningOpRef<ContainerOpT>();
     return opRef;
   }
+}
 } // namespace detail
 
 /// This parses the file specified by the indicated SourceMgr and appends parsed
 /// operations to the given block. If the block is non-empty, the operations are
 /// placed before the current terminator. If parsing is successful, success is
 /// returned. Otherwise, an error message is emitted through the error handler
 /// registered in the context, and failure is returned. If `sourceFileLoc` is
 /// non-null, it is populated with a file location representing the start of the

 /// error message is emitted through the error handler registered in the
 /// context, and failure is returned. If `sourceFileLoc` is non-null, it is
 /// populated with a file location representing the start of the source file
 /// that is being parsed.
 LogicalResult parseSourceString(llvm::StringRef sourceStr, Block *block,
                                 const ParserConfig &config,
                                 LocationAttr *sourceFileLoc = nullptr);
 
 namespace detail {
 /// The internal implementation of the templated `parseSourceFile` methods
 /// below, that simply forwards to the non-templated version.
 template <typename ContainerOpT, typename... ParserArgs>
 inline OwningOpRef<ContainerOpT> parseSourceFile(const ParserConfig &config,
                                                  ParserArgs &&...args) {
   LocationAttr sourceFileLoc;
   Block block;
   if (failed(parseSourceFile(std::forward<ParserArgs>(args)..., &block, config,
                              &sourceFileLoc)))
     return OwningOpRef<ContainerOpT>();
   return detail::constructContainerOpForParserIfNecessary<ContainerOpT>(
       &block, config.getContext(), sourceFileLoc);
 }
 } // namespace detail
 
 /// This parses the file specified by the indicated SourceMgr. If the source IR
 /// contained a single instance of `ContainerOpT`, it is returned. Otherwise, a
 /// new instance of `ContainerOpT` is constructed containing all of the parsed
 /// operations. If parsing was not successful, null is returned and an error
 /// message is emitted through the error handler registered in the context, and
 /// failure is returned. `ContainerOpT` is required to have a single region
 /// containing a single block, and must implement the
 /// `SingleBlockImplicitTerminator` trait.
-template <typename ContainerOpT>
+template <typename ContainerOpT = Operation *>
 inline OwningOpRef<ContainerOpT>
 parseSourceFile(const llvm::SourceMgr &sourceMgr, const ParserConfig &config) {
   return detail::parseSourceFile<ContainerOpT>(config, sourceMgr);
 }
 
 /// This parses the file specified by the indicated filename. If the source IR
 /// contained a single instance of `ContainerOpT`, it is returned. Otherwise, a
 /// new instance of `ContainerOpT` is constructed containing all of the parsed
 /// operations. If parsing was not successful, null is returned and an error
 /// message is emitted through the error handler registered in the context, and
 /// failure is returned. `ContainerOpT` is required to have a single region
 /// containing a single block, and must implement the
 /// `SingleBlockImplicitTerminator` trait.
-template <typename ContainerOpT>
+template <typename ContainerOpT = Operation *>
 inline OwningOpRef<ContainerOpT> parseSourceFile(StringRef filename,
                                                  const ParserConfig &config) {
   return detail::parseSourceFile<ContainerOpT>(config, filename);
 }
 
 /// This parses the file specified by the indicated filename using the provided
 /// SourceMgr. If the source IR contained a single instance of `ContainerOpT`,
 /// it is returned. Otherwise, a new instance of `ContainerOpT` is constructed
 /// containing all of the parsed operations. If parsing was not successful, null
 /// is returned and an error message is emitted through the error handler
 /// registered in the context, and failure is returned. `ContainerOpT` is
 /// required to have a single region containing a single block, and must
 /// implement the `SingleBlockImplicitTerminator` trait.
-template <typename ContainerOpT>
+template <typename ContainerOpT = Operation *>
 inline OwningOpRef<ContainerOpT> parseSourceFile(llvm::StringRef filename,
                                                  llvm::SourceMgr &sourceMgr,
                                                  const ParserConfig &config) {
   return detail::parseSourceFile<ContainerOpT>(config, filename, sourceMgr);
 }
 
 /// This parses the provided string containing MLIR. If the source IR contained
 /// a single instance of `ContainerOpT`, it is returned. Otherwise, a new
 /// instance of `ContainerOpT` is constructed containing all of the parsed
 /// operations. If parsing was not successful, null is returned and an error
 /// message is emitted through the error handler registered in the context, and
 /// failure is returned. `ContainerOpT` is required to have a single region
 /// containing a single block, and must implement the
 /// `SingleBlockImplicitTerminator` trait.
-template <typename ContainerOpT>
+template <typename ContainerOpT = Operation *>
 inline OwningOpRef<ContainerOpT> parseSourceString(llvm::StringRef sourceStr,
                                                    const ParserConfig &config) {
   LocationAttr sourceFileLoc;
   Block block;
   if (failed(parseSourceString(sourceStr, &block, config, &sourceFileLoc)))
     return OwningOpRef<ContainerOpT>();
   return detail::constructContainerOpForParserIfNecessary<ContainerOpT>(
       &block, config.getContext(), sourceFileLoc);
 }
 
 } // namespace mlir
 
 #endif // MLIR_PARSER_PARSER_H

mlir/include/mlir/Tools/ParseUtilties.h

+//===- ParseUtilities.h - MLIR Tool Parse Utilities -------------*- C++ -*-===//
+//
+// 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 file containts common utilities for implementing the file-parsing
+// behaviour for MLIR tools.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_PARSEUTILITIES_H
+#define MLIR_TOOLS_PARSEUTILITIES_H
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Parser/Parser.h"
+
+namespace mlir {
+/// This parses the file specified by the indicated SourceMgr. If parsing was
+/// not successful, null is returned and an error message is emitted through the
+/// error handler registered in the context.
+/// If 'insertImplicitModule' is true a top-level 'builtin.module' op will be
+/// inserted that contains the parsed IR, unless one exists already.
+inline OwningOpRef<Operation *>
+parseSourceFileForTool(llvm::SourceMgr &sourceMgr, const ParserConfig &config,
+                       bool insertImplicitModule) {
+  if (insertImplicitModule) {
+    // TODO: Move implicit module logic out of 'parseSourceFile' and into here.
+    return parseSourceFile<ModuleOp>(sourceMgr, config)
+        .release()
+        .getOperation();
+  }
+  return parseSourceFile(sourceMgr, config);
+}
+} // namespace mlir
+
+#endif // MLIR_TOOLS_PARSEUTILITIES_H

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

 /// against emitted diagnostics.
 /// - verifyPasses enables the IR verifier in-between each pass in the pipeline.
 /// - allowUnregisteredDialects allows to parse and create operation without
 /// registering the Dialect in the MLIRContext.
 /// - preloadDialectsInContext will trigger the upfront loading of all
 ///   dialects from the global registry in the MLIRContext. This option is
 ///   deprecated and will be removed soon.
 /// - emitBytecode will generate bytecode output instead of text.
-LogicalResult MlirOptMain(llvm::raw_ostream &outputStream,
-                          std::unique_ptr<llvm::MemoryBuffer> buffer,
-                          const PassPipelineCLParser &passPipeline,
-                          DialectRegistry &registry, bool splitInputFile,
-                          bool verifyDiagnostics, bool verifyPasses,
-                          bool allowUnregisteredDialects,
-                          bool preloadDialectsInContext = false,
-                          bool emitBytecode = false);
+/// - implicitModule will enable implicit addition of a top-level
+/// 'builtin.module' if one doesn't already exist.
+LogicalResult MlirOptMain(
+    llvm::raw_ostream &outputStream, std::unique_ptr<llvm::MemoryBuffer> buffer,
+    const PassPipelineCLParser &passPipeline, DialectRegistry &registry,
+    bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
+    bool allowUnregisteredDialects, bool preloadDialectsInContext = false,
+    bool emitBytecode = false, bool implicitModule = false);
 
 /// Support a callback to setup the pass manager.
 /// - passManagerSetupFn is the callback invoked to setup the pass manager to
 ///   apply on the loaded IR.
-LogicalResult MlirOptMain(llvm::raw_ostream &outputStream,
-                          std::unique_ptr<llvm::MemoryBuffer> buffer,
-                          PassPipelineFn passManagerSetupFn,
-                          DialectRegistry &registry, bool splitInputFile,
-                          bool verifyDiagnostics, bool verifyPasses,
-                          bool allowUnregisteredDialects,
-                          bool preloadDialectsInContext = false,
-                          bool emitBytecode = false);
+LogicalResult MlirOptMain(
+    llvm::raw_ostream &outputStream, std::unique_ptr<llvm::MemoryBuffer> buffer,
+    PassPipelineFn passManagerSetupFn, DialectRegistry &registry,
+    bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
+    bool allowUnregisteredDialects, bool preloadDialectsInContext = false,
+    bool emitBytecode = false, bool implicitModule = false);
 
 /// Implementation for tools like `mlir-opt`.
 /// - toolName is used for the header displayed by `--help`.
 /// - registry should contain all the dialects that can be parsed in the source.
 /// - preloadDialectsInContext will trigger the upfront loading of all
 ///   dialects from the global registry in the MLIRContext. This option is
 ///   deprecated and will be removed soon.
 LogicalResult MlirOptMain(int argc, char **argv, llvm::StringRef toolName,

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/DebugCounter.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/Timing.h"
 #include "mlir/Support/ToolUtilities.h"
+#include "mlir/Tools/ParseUtilties.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 using namespace llvm;
 
 /// Perform the actions on the input file indicated by the command line flags
 /// within the specified context.
 ///
 /// This typically parses the main source file, runs zero or more optimization
 /// passes, then prints the output.
 ///
 static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,
                                     bool verifyPasses, SourceMgr &sourceMgr,
                                     MLIRContext *context,
                                     PassPipelineFn passManagerSetupFn,
-                                    bool emitBytecode) {
+                                    bool emitBytecode, bool implicitModule) {
   DefaultTimingManager tm;
   applyDefaultTimingManagerCLOptions(tm);
   TimingScope timing = tm.getRootScope();
 
   // Disable multi-threading when parsing the input file. This removes the
   // unnecessary/costly context synchronization when parsing.
   bool wasThreadingEnabled = context->isMultithreadingEnabled();
   context->disableMultithreading();
 
   // Prepare the parser config, and attach any useful/necessary resource
   // handlers. Unhandled external resources are treated as passthrough, i.e.
   // they are not processed and will be emitted directly to the output
   // untouched.
   PassReproducerOptions reproOptions;
   FallbackAsmResourceMap fallbackResourceMap;
   ParserConfig config(context, &fallbackResourceMap);
   reproOptions.attachResourceParser(config);
 
   // Parse the input file and reset the context threading state.
   TimingScope parserTiming = timing.nest("Parser");
-  OwningOpRef<ModuleOp> module(parseSourceFile<ModuleOp>(sourceMgr, config));
+  OwningOpRef<Operation *> op =
+      parseSourceFileForTool(sourceMgr, config, implicitModule);
   context->enableMultithreading(wasThreadingEnabled);
-  if (!module)
+  if (!op)
     return failure();
   parserTiming.stop();
 
   // Prepare the pass manager, applying command-line and reproducer options.
   PassManager pm(context, OpPassManager::Nesting::Implicit,
-                 module->getOperationName());
+                 op.get()->getName().getStringRef());
   pm.enableVerifier(verifyPasses);
   applyPassManagerCLOptions(pm);
   pm.enableTiming(timing);
   if (failed(reproOptions.apply(pm)) || failed(passManagerSetupFn(pm)))
     return failure();
 
   // Run the pipeline.
-  if (failed(pm.run(*module)))
+  if (failed(pm.run(*op)))
     return failure();
 
   // Print the output.
   TimingScope outputTiming = timing.nest("Output");
   if (emitBytecode) {
     BytecodeWriterConfig writerConfig(fallbackResourceMap);
-    writeBytecodeToFile(module->getOperation(), os, writerConfig);
+    writeBytecodeToFile(op.get(), os, writerConfig);
   } else {
-    AsmState asmState(*module, OpPrintingFlags(), /*locationMap=*/nullptr,
+    AsmState asmState(op.get(), OpPrintingFlags(), /*locationMap=*/nullptr,
                       &fallbackResourceMap);
-    module->print(os, asmState);
+    op.get()->print(os, asmState);
     os << '\n';
   }
   return success();
 }
 
 /// Parses the memory buffer.  If successfully, run a series of passes against
 /// it and print the result.
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<MemoryBuffer> ownedBuffer,
               bool verifyDiagnostics, bool verifyPasses,
               bool allowUnregisteredDialects, bool preloadDialectsInContext,
-              bool emitBytecode, PassPipelineFn passManagerSetupFn,
-              DialectRegistry &registry, llvm::ThreadPool *threadPool) {
+              bool emitBytecode, bool implicitModule,
+              PassPipelineFn passManagerSetupFn, DialectRegistry &registry,
+              llvm::ThreadPool *threadPool) {
   // Tell sourceMgr about this buffer, which is what the parser will pick up.
   SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
 
   // Create a context just for the current buffer. Disable threading on creation
   // since we'll inject the thread-pool separately.
   MLIRContext context(registry, MLIRContext::Threading::DISABLED);
   if (threadPool)
     context.setThreadPool(*threadPool);
 
   // Parse the input file.
   if (preloadDialectsInContext)
     context.loadAllAvailableDialects();
   context.allowUnregisteredDialects(allowUnregisteredDialects);
   if (verifyDiagnostics)
     context.printOpOnDiagnostic(false);
   context.getDebugActionManager().registerActionHandler<DebugCounter>();
 
   // If we are in verify diagnostics mode then we have a lot of work to do,
   // otherwise just perform the actions without worrying about it.
   if (!verifyDiagnostics) {
     SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
     return performActions(os, verifyDiagnostics, verifyPasses, sourceMgr,
-                          &context, passManagerSetupFn, emitBytecode);
+                          &context, passManagerSetupFn, emitBytecode,
+                          implicitModule);
   }
 
   SourceMgrDiagnosticVerifierHandler sourceMgrHandler(sourceMgr, &context);
 
   // Do any processing requested by command line flags.  We don't care whether
   // these actions succeed or fail, we only care what diagnostics they produce
   // and whether they match our expectations.
   (void)performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
-                       passManagerSetupFn, emitBytecode);
+                       passManagerSetupFn, emitBytecode, implicitModule);
 
   // Verify the diagnostic handler to make sure that each of the diagnostics
   // matched.
   return sourceMgrHandler.verify();
 }
 
 LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,
                                 std::unique_ptr<MemoryBuffer> buffer,
                                 PassPipelineFn passManagerSetupFn,
                                 DialectRegistry &registry, bool splitInputFile,
                                 bool verifyDiagnostics, bool verifyPasses,
                                 bool allowUnregisteredDialects,
                                 bool preloadDialectsInContext,
-                                bool emitBytecode) {
+                                bool emitBytecode, bool implicitModule) {
   // The split-input-file mode is a very specific mode that slices the file
   // up into small pieces and checks each independently.
   // We use an explicit threadpool to avoid creating and joining/destroying
   // threads for each of the split.
   ThreadPool *threadPool = nullptr;
 
   // Create a temporary context for the sake of checking if
   // --mlir-disable-threading was passed on the command line.
   // We use the thread-pool this context is creating, and avoid
   // creating any thread when disabled.
   MLIRContext threadPoolCtx;
   if (threadPoolCtx.isMultithreadingEnabled())
     threadPool = &threadPoolCtx.getThreadPool();
 
   auto chunkFn = [&](std::unique_ptr<MemoryBuffer> chunkBuffer,
                      raw_ostream &os) {
     return processBuffer(os, std::move(chunkBuffer), verifyDiagnostics,
                          verifyPasses, allowUnregisteredDialects,
-                         preloadDialectsInContext, emitBytecode,
+                         preloadDialectsInContext, emitBytecode, implicitModule,
                          passManagerSetupFn, registry, threadPool);
   };
   return splitAndProcessBuffer(std::move(buffer), chunkFn, outputStream,
                                splitInputFile, /*insertMarkerInOutput=*/true);
 }
 
 LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,
                                 std::unique_ptr<MemoryBuffer> buffer,
                                 const PassPipelineCLParser &passPipeline,
                                 DialectRegistry &registry, bool splitInputFile,
                                 bool verifyDiagnostics, bool verifyPasses,
                                 bool allowUnregisteredDialects,
                                 bool preloadDialectsInContext,
-                                bool emitBytecode) {
+                                bool emitBytecode, bool implicitModule) {
   auto passManagerSetupFn = [&](PassManager &pm) {
     auto errorHandler = [&](const Twine &msg) {
       emitError(UnknownLoc::get(pm.getContext())) << msg;
       return failure();
     };
     return passPipeline.addToPipeline(pm, errorHandler);
   };
   return MlirOptMain(outputStream, std::move(buffer), passManagerSetupFn,
                      registry, splitInputFile, verifyDiagnostics, verifyPasses,
                      allowUnregisteredDialects, preloadDialectsInContext,
-                     emitBytecode);
+                     emitBytecode, implicitModule);
 }
 
 LogicalResult mlir::MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
                                 DialectRegistry &registry,
                                 bool preloadDialectsInContext) {
   static cl::opt<std::string> inputFilename(
       cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
LogicalResult mlir::MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
   static cl::opt<bool> showDialects(
       "show-dialects", cl::desc("Print the list of registered dialects"),
       cl::init(false));
 
   static cl::opt<bool> emitBytecode(
       "emit-bytecode", cl::desc("Emit bytecode when generating output"),
       cl::init(false));
 
+  static cl::opt<bool> noImplicitModule{
+      "no-implicit-module",
+      cl::desc(
+          "Disable implicit addition of a top-level module op during parsing"),
+      cl::init(false)};
+
   InitLLVM y(argc, argv);
 
   // Register any command line options.
   registerAsmPrinterCLOptions();
   registerMLIRContextCLOptions();
   registerPassManagerCLOptions();
   registerDefaultTimingManagerCLOptions();
   DebugCounter::registerCLOptions();
LogicalResult mlir::MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
   if (!output) {
     llvm::errs() << errorMessage << "\n";
     return failure();
   }
 
   if (failed(MlirOptMain(output->os(), std::move(file), passPipeline, registry,
                          splitInputFile, verifyDiagnostics, verifyPasses,
                          allowUnregisteredDialects, preloadDialectsInContext,
-                         emitBytecode)))
+                         emitBytecode, /*implicitModule=*/!noImplicitModule)))
     return failure();
 
   // Keep the output file if the invocation of MlirOptMain was successful.
   output->keep();
   return success();
 }

mlir/test/IR/top-level.mlir

+// RUN: mlir-opt --no-implicit-module --verify-diagnostics --split-input-file %s | FileCheck %s
+
+// CHECK-NOT: module
+//     CHECK: func.func
+func.func private @foo()
+
+// -----
+
+// expected-error@-3 {{source must contain a single top-level operation, found: 2}}
+func.func private @bar()
+func.func private @baz()
+
+// -----
+
+// expected-error@-3 {{source must contain a single top-level operation, found: 0}}

mlir/test/Pass/pipeline-invalid.mlir

+// RUN: mlir-opt --no-implicit-module --canonicalize --verify-diagnostics --split-input-file
+
+// expected-error@below {{trying to schedule a pass on an operation not marked as 'IsolatedFromAbove'}}
+arith.constant 0
+
+// -----
+
+// expected-error@below {{trying to schedule a pass on an unregistered operation}}
+"test.op"() : () -> ()