[mlir][bytecode] Allow client to specify an older version of the bytecode to emit

[jpienaar]

Summary

Add method to set a desired bytecode file format to generate. Change
write method to be able to return minimum bytecode version needed in
reader. This enables generating an older version of the bytecode (not
dialect ops, attributes or types). But this does not guarantee that an
older version can always be generated. This clamps setting to at most
current version.

[rriddle]

If we can't guarantee it can be generated, I don't think this should be added.

Aside from that, I'd like for us to finish up things we want to add to the format before we start to consider guaranteeing compatibility in this way.

[mehdi_amini]

mlir/test/Bytecode/versioning/versioned_bytecode.mlir

15

(newline)

[jpienaar]

Fix build

[mfrancio]

In D146555#4210628, @rriddle wrote:

If we can't guarantee it can be generated, I don't think this should be added.

I don't think it can ever be a guarantee, but if the starting point is generic enough, you shouldn't hit compatibility issues anytime soon. The benefits of having this severely outweighs the risks of breaking compatibility.

Aside from that, I'd like for us to finish up things we want to add to the format before we start to consider guaranteeing compatibility in this way.

I agree with this.

[saksenadhruv]

In D146555#4217555, @mfrancio wrote:

In D146555#4210628, @rriddle wrote:

If we can't guarantee it can be generated, I don't think this should be added.

I don't think it can ever be a guarantee, but if the starting point is generic enough, you shouldn't hit compatibility issues anytime soon. The benefits of having this severely outweighs the risks of breaking compatibility.

I will go one step further and say, we need to strive for a guarantee, that is what stability should be, which would allow us to write a serialized format which works on an older os, the one we shipped the first version with.

[jpienaar]

Make clamp instead of fail and enable dialect writer to query set version

This was flagged as being needed to handle cases where dialect could use feature not at bytecode to serialize. There is no failure path added there for writes yet.

[mehdi_amini]

Adding the API does not commit us to much right now though, even if we add the

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

92

Instead of an optional, can we just default initialize it with the current bytecode version? It may simplify the call-sites in the future...

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

889–890

This API will need to return a LogicalResult somehow to express failures...

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

96

The help message needs an update

98

We should likely check somewhere that emit-bytecode-version is not set without emit-bytecode

[jpienaar]

Return error status for write method.

[jpienaar]

Yes, worst case this enables quantifying impact for formalizing expectations.

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

92

The current bytecode version is private in lib/Bytecode/Encoding.h - splitting it out (had chosen mlir/Bytecode/BytecodeVersion.h) resulted in this file depending on file in bytecode which felt a bit weird.

[jpienaar]

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

92

This is currently private inside lib/Bytecode/Encoding.h - I thought about exposing it in mlir/Bytecode/BytecodeVersion.h but then Tools/mlir-opt depended on Bytecode which felt a bit odd. Let me know and I can change it (I mean given clamp behavior, I could initialize this to maxint here and it would behave the same).

[mehdi_amini]

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

92

LG!

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

889–890

I was wondering about this today and felt that LogicalResult is a bit broad: we make it seems like serialization can fail in general, but we only want to fail if a specific bytecode version was requested and not honored.

So what about returning the actual minimum version of the reader that will be needer to read the bytecode?
If a method from version 4 is used by a dialect and the client requested version 2, we'd return 4, and it's up to the client to decide if they want to fail or not.

[jpienaar]

Return min bytecode reader needs to support instead of failure, but make it failure in mlir-opt if the requested and required do not match.

[jpienaar]

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

889–890

Works for me - made the opt tool behavior an error if not request version.

[jpienaar]

Rebase

[jpienaar]

Plumb through to Python

[mehdi_amini]

LGTM, but please wait for River's feedback as well!

[GleasonK]

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

889–890

If a method from version 4 is used by a dialect and the client requested version 2, we'd return 4

If we can make forward compatibility a matter of the dialects used, that would be great! The StableHLO team is very interested in upstream forward compatibility, happy to follow more strict dialect policies to make it work if needed.

[jpienaar]

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

889–890

If we can make forward compatibility a matter of the dialects used

Not sure I follow. I believe Mehdi's proposal here is that if a dialect uses a write method only available at version X then return at least X (now, we have no such case at the moment so nothing modifies the set number yet). But a dialect can query the requested bytecode version and decide which method to use. So its under the dialects control to only use encoding methods available at a specific version: its a function of methods used rather than dialects used, as a given dialect could still use new encoding methods but the module/op serialized just doesn't use any of those and it would still be be able to serialize with the old.

[rriddle]

mlir/include/mlir/Bytecode/BytecodeWriter.h

43–45

I would likely name this something more explicit, like: trySetBytecodeVersion, given that it isn't guaranteed to actually set the version provided. We could return the actual version used, and let the user decide what to do about it.

92

Please create a result struct for this. Returning an integer feels a bit too opaque here.

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

31–32

Note: This is only set if a specific set version can be emitted.

This felt a bit weird to read. It might be more accurate to say it only differs from kVersion if ...

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

55–68

Why do we need a custom parser for optional? Why not just use the getNumOccurrences method to check if this has been set?

[jpienaar]

(updating to struct but wanted to check on other parts in parallel)

mlir/include/mlir/Bytecode/BytecodeWriter.h

43–45

How about setDesiredBytecodeVersion? Here we don't yet know what the dialects involved would be doing, so couldn't return actual version and instead returning it from write entry point.

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

55–68

Usage of external storage - at least I couldn't find nice way that doesn't use sentinel or other usage like this.

[jpienaar]

Use a more explicit return struct from writer.

[jpienaar]

Fixing formatting

[jpienaar]

Retrying clang-format

[rriddle]

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

888–889 ↗

(On Diff #518105)

Do we need the comment or the void cast at all here anymore?

[mehdi_amini]

mlir/include/mlir-c/IR.h

568

Can you make this nodiscard?

[mehdi_amini]

We don't have a test where the bitcode gets emitted at a higher requirement than requested. I think we would actually emit bitcode that can't be loaded anymore.

That is we can't change the bitcode version in the middle of the emission, it would create inconsistent version within the file.

mlir/test/Bytecode/versioning/versioned_bytecode.mlir

11

I don't think we check here what the actual emitted version is?

[mehdi_amini]

mlir/test/Bytecode/versioning/versioned_bytecode.mlir

11

Actually scratch that: mlir-opt would error out if it wasn't the requested version

[jpienaar]

In D146555#4308317, @mehdi_amini wrote:

We don't have a test where the bitcode gets emitted at a higher requirement than requested. I think we would actually emit bitcode that can't be loaded anymore.

That is we can't change the bitcode version in the middle of the emission, it would create inconsistent version within the file.

You are correct, when this was just returning a failure result it was fine but with version returned and "auto relaxing" not so much. I don't know if general case can be supported except by attempting to emit and then redoing it (at which point success or not can be returned and caller could decide to redo instead).

[mehdi_amini]

Yeah I don't see another way, we should probably just abort the emission and emit an error when a dialect emits with a newer version.

mlir/include/mlir-c/IR.h

 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
+DEFINE_C_API_STRUCT(MlirBytecodeWriterConfig, void);
 DEFINE_C_API_STRUCT(MlirContext, void);
 DEFINE_C_API_STRUCT(MlirDialect, void);
 DEFINE_C_API_STRUCT(MlirDialectRegistry, void);
 DEFINE_C_API_STRUCT(MlirOperation, void);
 DEFINE_C_API_STRUCT(MlirOpOperand, void);
 DEFINE_C_API_STRUCT(MlirOpPrintingFlags, void);
 DEFINE_C_API_STRUCT(MlirBlock, void);
 DEFINE_C_API_STRUCT(MlirRegion, void);

 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
 
 /// Do not verify the operation when using custom operation printers.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags);
 
 //===----------------------------------------------------------------------===//
+// Bytecode printing flags API.
+//===----------------------------------------------------------------------===//
+
+/// Creates new printing flags with defaults, intended for customization.
+/// Must be freed with a call to mlirBytecodeWriterConfigDestroy().
+MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig
+mlirBytecodeWriterConfigCreate(void);
+
+/// Destroys printing flags created with mlirBytecodeWriterConfigCreate.
+MLIR_CAPI_EXPORTED void
+mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config);
+
+/// Sets the version to emit in the writer config.
+MLIR_CAPI_EXPORTED void
+mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
+                                           int64_t version);
+
+//===----------------------------------------------------------------------===//
 // Operation API.
 //===----------------------------------------------------------------------===//
 
 /// Creates an operation and transfers ownership to the caller.
 /// Note that caller owned child objects are transferred in this call and must
 /// not be further used. Particularly, this applies to any regions added to
 /// the state (the implementation may invalidate any such pointers).
 ///

 
 /// Same as mlirOperationPrint but accepts flags controlling the printing
 /// behavior.
 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op,
                                                     MlirOpPrintingFlags flags,
                                                     MlirStringCallback callback,
                                                     void *userData);
 
-/// Same as mlirOperationPrint but writing the bytecode format out.
-MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op,
-                                                   MlirStringCallback callback,
-                                                   void *userData);
+struct MlirBytecodeWriterResult {
+  int64_t minVersion;
+};
+typedef struct MlirBytecodeWriterResult MlirBytecodeWriterResult;
+
+inline static bool
+mlirBytecodeWriterResultGetMinVersion(MlirBytecodeWriterResult res) {
+  return res.minVersion;
+}
+
+/// Same as mlirOperationPrint but writing the bytecode format and returns the
+/// minimum bytecode version the consumer needs to support.
+MLIR_CAPI_EXPORTED MlirBytecodeWriterResult mlirOperationWriteBytecode(
+    MlirOperation op, MlirStringCallback callback, void *userData);
+
+/// Same as mlirOperationWriteBytecode but with writer config.
+MLIR_CAPI_EXPORTED MlirBytecodeWriterResult
+mlirOperationWriteBytecodeWithConfig(MlirOperation op,
+                                     MlirBytecodeWriterConfig config,
 
 /// Prints an operation to stderr.
 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op);
 
 /// Verify the operation and return true if it passes, false if it fails.
 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op);
 
 /// Moves the given operation immediately after the other operation in its

mlir/include/mlir/Bytecode/BytecodeImplementation.h

public:
   /// only be called if such a guarantee can be made, such as when the string is
   /// owned by an attribute or type.
   virtual void writeOwnedString(StringRef str) = 0;
 
   /// Write a blob to the bytecode, which is owned by the caller and is
   /// guaranteed to not die before the end of the bytecode process. The blob is
   /// written as-is, with no additional compression or compaction.
   virtual void writeOwnedBlob(ArrayRef<char> blob) = 0;
+
+  /// Return the bytecode version being emitted for.
+  virtual int64_t getBytecodeVersion() const = 0;
 };
 
 //===--------------------------------------------------------------------===//
 // Dialect Version Interface.
 //===--------------------------------------------------------------------===//
 
 /// This class is used to represent the version of a dialect, for the purpose
 /// of polymorphic destruction.

mlir/include/mlir/Bytecode/BytecodeWriter.h

public:
 
   /// An internal implementation class that contains the state of the
   /// configuration.
   struct Impl;
 
   /// Return an instance of the internal implementation.
   const Impl &getImpl() const { return *impl; }
 
+  /// Set the desired bytecode version to emit. This function clamps the version
+  /// to the existing version if larger than existing. The desired version may
+  /// not be used depending on the features used and the actual version required
+  /// is returned by bytecode writer entry point.
+  void setDesiredBytecodeVersion(int64_t bytecodeVersion);
+
   //===--------------------------------------------------------------------===//
   // Resources
   //===--------------------------------------------------------------------===//
 
   /// Attach the given resource printer to the writer configuration.
   void attachResourcePrinter(std::unique_ptr<AsmResourcePrinter> printer);
 
   /// Attach an resource printer, in the form of a callable, to the
for (auto &printer : map.getPrinters())
       attachResourcePrinter(std::move(printer));
   }
 
 private:
   /// A pointer to allocated storage for the impl state.
   std::unique_ptr<Impl> impl;
 };
 
+/// Status of bytecode serialization.
+struct BytecodeWriterResult {
+  /// The minimum version of the reader required to read the serialized file.
+  int64_t minVersion;
+};
+
 //===----------------------------------------------------------------------===//
 // Entry Points
 //===----------------------------------------------------------------------===//
 
 /// Write the bytecode for the given operation to the provided output stream.
 /// For streams where it matters, the given stream should be in "binary" mode.
-void writeBytecodeToFile(Operation *op, raw_ostream &os,
-                         const BytecodeWriterConfig &config = {});
+BytecodeWriterResult
+writeBytecodeToFile(Operation *op, raw_ostream &os,
 
 } // namespace mlir
 
 #endif // MLIR_BYTECODE_BYTECODEWRITER_H

mlir/include/mlir/CAPI/IR.h

 // core MLIR classes. This file should not be included from C++ code other than
 // C API implementation nor from C code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_IR_H
 #define MLIR_CAPI_IR_H
 
+#include "mlir/Bytecode/BytecodeWriter.h"
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Operation.h"
 
+DEFINE_C_API_PTR_METHODS(MlirBytecodeWriterConfig, mlir::BytecodeWriterConfig)
 DEFINE_C_API_PTR_METHODS(MlirContext, mlir::MLIRContext)
 DEFINE_C_API_PTR_METHODS(MlirDialect, mlir::Dialect)
 DEFINE_C_API_PTR_METHODS(MlirDialectRegistry, mlir::DialectRegistry)
 DEFINE_C_API_PTR_METHODS(MlirOperation, mlir::Operation)
 DEFINE_C_API_PTR_METHODS(MlirBlock, mlir::Block)
 DEFINE_C_API_PTR_METHODS(MlirOpOperand, mlir::OpOperand)
 DEFINE_C_API_PTR_METHODS(MlirOpPrintingFlags, mlir::OpPrintingFlags)
 DEFINE_C_API_PTR_METHODS(MlirRegion, mlir::Region)

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

public:
   bool shouldEmitBytecode() const { return emitBytecodeFlag; }
 
   /// Set the IRDL file to load before processing the input.
   MlirOptMainConfig &setIrdlFile(StringRef file) {
     irdlFileFlag = file;
     return *this;
   }
   StringRef getIrdlFile() const { return irdlFileFlag; }
 
+  /// Set the bytecode version to emit.
+  MlirOptMainConfig &setEmitBytecodeVersion(int64_t version) {
+    emitBytecodeVersion = version;
+    return *this;
+  }
+  std::optional<int64_t> bytecodeVersionToEmit() const {
+    return emitBytecodeVersion;
+  }
+
   /// Set the callback to populate the pass manager.
   MlirOptMainConfig &
   setPassPipelineSetupFn(std::function<LogicalResult(PassManager &)> callback) {
     passPipelineCallback = std::move(callback);
     return *this;
   }
 
   /// Set the parser to use to populate the pass manager.
protected:
   bool enableDebuggerActionHookFlag = false;
 
   /// IRDL file to register before processing the input.
   std::string irdlFileFlag = "";
 
   /// Location Breakpoints to filter the action logging.
   std::vector<tracing::BreakpointManager *> logActionLocationFilter;
 
+  /// Emit bytecode at given version.
+  std::optional<int64_t> emitBytecodeVersion = std::nullopt;
+
   /// The callback to populate the pass manager.
   std::function<LogicalResult(PassManager &)> passPipelineCallback;
 
   /// Show the registered dialects before trying to load the input file.
   bool showDialectsFlag = false;
 
   /// Split the input file based on the `// -----` marker into pieces and
   /// process each chunk independently.

mlir/lib/Bindings/Python/IRCore.cpp

Returns:
   argument.
 )";
 
 static const char kOperationPrintBytecodeDocstring[] =
     R"(Write the bytecode form of the operation to a file like object.
 
 Args:
   file: The file like object to write to.
+  desired_version: The version of bytecode to emit.
+Returns:
+  The bytecode writer status.
 )";
 
 static const char kOperationStrDunderDocstring[] =
     R"(Gets the assembly form of the operation with default options.
 
 If more advanced control over the assembly formatting or I/O options is needed,
 use the dedicated print or get_asm method, which supports keyword arguments to
 customize behavior.
if (assumeVerified)
     mlirOpPrintingFlagsAssumeVerified(flags);
 
   PyFileAccumulator accum(fileObject, binary);
   mlirOperationPrintWithFlags(operation, flags, accum.getCallback(),
                               accum.getUserData());
   mlirOpPrintingFlagsDestroy(flags);
 }
 
-void PyOperationBase::writeBytecode(const py::object &fileObject) {
+MlirBytecodeWriterResult
+PyOperationBase::writeBytecode(const py::object &fileObject,
+                               std::optional<int64_t> bytecodeVersion) {
   PyOperation &operation = getOperation();
   operation.checkValid();
   PyFileAccumulator accum(fileObject, /*binary=*/true);
-  mlirOperationWriteBytecode(operation, accum.getCallback(),
+
+  if (!bytecodeVersion.has_value())
+    return mlirOperationWriteBytecode(operation, accum.getCallback(),
                                       accum.getUserData());
+
+  MlirBytecodeWriterConfig config = mlirBytecodeWriterConfigCreate();
+  mlirBytecodeWriterConfigDesiredEmitVersion(config, *bytecodeVersion);
+  return mlirOperationWriteBytecodeWithConfig(
+      operation, config, accum.getCallback(), accum.getUserData());
 }
 
 py::object PyOperationBase::getAsm(bool binary,
                                    std::optional<int64_t> largeElementsLimit,
                                    bool enableDebugInfo, bool prettyDebugInfo,
                                    bool printGenericOpForm, bool useLocalScope,
                                    bool assumeVerified) {
   py::object fileObject;
py::class_<PyOperationBase>(m, "_OperationBase", py::module_local())
            py::arg("file") = py::none(), py::arg("binary") = false,
            py::arg("large_elements_limit") = py::none(),
            py::arg("enable_debug_info") = false,
            py::arg("pretty_debug_info") = false,
            py::arg("print_generic_op_form") = false,
            py::arg("use_local_scope") = false,
            py::arg("assume_verified") = false, kOperationPrintDocstring)
       .def("write_bytecode", &PyOperationBase::writeBytecode, py::arg("file"),
+           py::arg("desired_version") = py::none(),
            kOperationPrintBytecodeDocstring)
       .def("get_asm", &PyOperationBase::getAsm,
            // Careful: Lots of arguments must match up with get_asm method.
            py::arg("binary") = false,
            py::arg("large_elements_limit") = py::none(),
            py::arg("enable_debug_info") = false,
            py::arg("pretty_debug_info") = false,
            py::arg("print_generic_op_form") = false,
py::class_<PySymbolTable>(m, "SymbolTable", py::module_local())
                   py::arg("symbol"), py::arg("visibility"))
       .def_static("replace_all_symbol_uses",
                   &PySymbolTable::replaceAllSymbolUses, py::arg("old_symbol"),
                   py::arg("new_symbol"), py::arg("from_op"))
       .def_static("walk_symbol_tables", &PySymbolTable::walkSymbolTables,
                   py::arg("from_op"), py::arg("all_sym_uses_visible"),
                   py::arg("callback"));
 
+  py::class_<MlirBytecodeWriterResult>(m, "BytecodeResult", py::module_local())
+      .def("min_version",
+           [](MlirBytecodeWriterResult &res) { return res.minVersion; });
+
   // Container bindings.
   PyBlockArgumentList::bind(m);
   PyBlockIterator::bind(m);
   PyBlockList::bind(m);
   PyOperationIterator::bind(m);
   PyOperationList::bind(m);
   PyOpAttributeMap::bind(m);
   PyOpOperandIterator::bind(m);

mlir/lib/Bindings/Python/IRModule.h

void print(pybind11::object fileObject, bool binary,
              bool assumeVerified);
   pybind11::object getAsm(bool binary,
                           std::optional<int64_t> largeElementsLimit,
                           bool enableDebugInfo, bool prettyDebugInfo,
                           bool printGenericOpForm, bool useLocalScope,
                           bool assumeVerified);
 
   // Implement the bound 'writeBytecode' method.
-  void writeBytecode(const pybind11::object &fileObject);
+  MlirBytecodeWriterResult
+  writeBytecode(const pybind11::object &fileObject,
+                std::optional<int64_t> bytecodeVersion);
 
   /// Moves the operation before or after the other operation.
   void moveAfter(PyOperationBase &other);
   void moveBefore(PyOperationBase &other);
 
   /// Verify the operation. Throws `MLIRError` if verification fails, and
   /// returns `true` otherwise.
   bool verify();

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

 
 //===----------------------------------------------------------------------===//
 // BytecodeWriterConfig
 //===----------------------------------------------------------------------===//
 
 struct BytecodeWriterConfig::Impl {
   Impl(StringRef producer) : producer(producer) {}
 
+  /// Version to use when writing.
+  /// Note: This only differs from kVersion if a specific version is set.
+  int64_t bytecodeVersion = bytecode::kVersion;
+
   /// The producer of the bytecode.
   StringRef producer;
 
   /// A collection of non-dialect resource printers.
   SmallVector<std::unique_ptr<AsmResourcePrinter>> externalResourcePrinters;
 };
 
 BytecodeWriterConfig::BytecodeWriterConfig(StringRef producer)
     : impl(std::make_unique<Impl>(producer)) {}
 BytecodeWriterConfig::BytecodeWriterConfig(FallbackAsmResourceMap &map,
                                            StringRef producer)
     : BytecodeWriterConfig(producer) {
   attachFallbackResourcePrinter(map);
 }
 BytecodeWriterConfig::~BytecodeWriterConfig() = default;
 
 void BytecodeWriterConfig::attachResourcePrinter(
     std::unique_ptr<AsmResourcePrinter> printer) {
   impl->externalResourcePrinters.emplace_back(std::move(printer));
 }
 
+void BytecodeWriterConfig::setDesiredBytecodeVersion(int64_t bytecodeVersion) {
+  // Clamp to current version.
+  impl->bytecodeVersion =
+      std::min<int64_t>(bytecodeVersion, bytecode::kVersion);
+}
+
 //===----------------------------------------------------------------------===//
 // EncodingEmitter
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class functions as the underlying encoding emitter for the bytecode
 /// writer. This class is a bit different compared to other types of encoders;
 /// it does not use a single buffer, but instead may contain several buffers
private:
   /// A set of strings referenced within the bytecode. The value of the map is
   /// unused.
   llvm::MapVector<llvm::CachedHashStringRef, size_t> strings;
 };
 } // namespace
 
 class DialectWriter : public DialectBytecodeWriter {
 public:
-  DialectWriter(EncodingEmitter &emitter, IRNumberingState &numberingState,
+  DialectWriter(int64_t bytecodeVersion, EncodingEmitter &emitter,
+                IRNumberingState &numberingState,
                 StringSectionBuilder &stringSection)
       : emitter(emitter), numberingState(numberingState),
         stringSection(stringSection) {}
 
   //===--------------------------------------------------------------------===//
   // IR
   //===--------------------------------------------------------------------===//
 
public:
   }
 
   void writeOwnedBlob(ArrayRef<char> blob) override {
     emitter.emitVarInt(blob.size());
     emitter.emitOwnedBlob(ArrayRef<uint8_t>(
         reinterpret_cast<const uint8_t *>(blob.data()), blob.size()));
   }
 
+  int64_t getBytecodeVersion() const override { return bytecodeVersion; }
+
 private:
+  int64_t bytecodeVersion;
   EncodingEmitter &emitter;
   IRNumberingState &numberingState;
   StringSectionBuilder &stringSection;
 };
 
 /// A simple raw_ostream wrapper around a EncodingEmitter. This removes the need
 /// to go through an intermediate buffer when interacting with code that wants a
 /// raw_ostream.

 
 //===----------------------------------------------------------------------===//
 // Bytecode Writer
 //===----------------------------------------------------------------------===//
 
 namespace {
 class BytecodeWriter {
 public:
-  BytecodeWriter(Operation *op) : numberingState(op) {}
+  BytecodeWriter(Operation *op, const BytecodeWriterConfig::Impl &config)
+      : numberingState(op), config(config) {}
 
   /// Write the bytecode for the given root operation.
-  void write(Operation *rootOp, raw_ostream &os,
-             const BytecodeWriterConfig::Impl &config);
+  void write(Operation *rootOp, raw_ostream &os);
 
 private:
   //===--------------------------------------------------------------------===//
   // Dialects
 
   void writeDialectSection(EncodingEmitter &emitter);
 
   //===--------------------------------------------------------------------===//
   // Attributes and Types
 
   void writeAttrTypeSection(EncodingEmitter &emitter);
 
   //===--------------------------------------------------------------------===//
   // Operations
 
   void writeBlock(EncodingEmitter &emitter, Block *block);
   void writeOp(EncodingEmitter &emitter, Operation *op);
   void writeRegion(EncodingEmitter &emitter, Region *region);
   void writeIRSection(EncodingEmitter &emitter, Operation *op);
 
   //===--------------------------------------------------------------------===//
   // Resources
 
-  void writeResourceSection(Operation *op, EncodingEmitter &emitter,
-                            const BytecodeWriterConfig::Impl &config);
+  void writeResourceSection(Operation *op, EncodingEmitter &emitter);
 
   //===--------------------------------------------------------------------===//
   // Strings
 
   void writeStringSection(EncodingEmitter &emitter);
 
   //===--------------------------------------------------------------------===//
   // Fields
 
   /// The builder used for the string section.
   StringSectionBuilder stringSection;
 
   /// The IR numbering state generated for the root operation.
   IRNumberingState numberingState;
+
+  /// Configuration dictating bytecode emission.
+  const BytecodeWriterConfig::Impl &config;
 };
 } // namespace
 
-void BytecodeWriter::write(Operation *rootOp, raw_ostream &os,
-                           const BytecodeWriterConfig::Impl &config) {
+void BytecodeWriter::write(Operation *rootOp, raw_ostream &os) {
   EncodingEmitter emitter;
 
   // Emit the bytecode file header. This is how we identify the output as a
   // bytecode file.
   emitter.emitString("ML\xefR");
 
   // Emit the bytecode version.
-  emitter.emitVarInt(bytecode::kVersion);
+  emitter.emitVarInt(config.bytecodeVersion);
 
   // Emit the producer.
   emitter.emitNulTerminatedString(config.producer);
 
   // Emit the dialect section.
   writeDialectSection(emitter);
 
   // Emit the attributes and types section.
   writeAttrTypeSection(emitter);
 
   // Emit the IR section.
   writeIRSection(emitter, rootOp);
 
   // Emit the resources section.
-  writeResourceSection(rootOp, emitter, config);
+  writeResourceSection(rootOp, emitter);
 
   // Emit the string section.
   writeStringSection(emitter);
 
   // Write the generated bytecode to the provided output stream.
   emitter.writeTo(os);
 }
 
void BytecodeWriter::writeDialectSection(EncodingEmitter &emitter) {
 
   // Emit the referenced dialects.
   auto dialects = numberingState.getDialects();
   dialectEmitter.emitVarInt(llvm::size(dialects));
   for (DialectNumbering &dialect : dialects) {
     // Write the string section and get the ID.
     size_t nameID = stringSection.insert(dialect.name);
 
+    if (config.bytecodeVersion == 0) {
+      dialectEmitter.emitVarInt(nameID);
+      continue;
+    }
+
     // Try writing the version to the versionEmitter.
     EncodingEmitter versionEmitter;
     if (dialect.interface) {
       // The writer used when emitting using a custom bytecode encoding.
-      DialectWriter versionWriter(versionEmitter, numberingState,
-                                  stringSection);
+      DialectWriter versionWriter(config.bytecodeVersion, versionEmitter,
+                                  numberingState, stringSection);
       dialect.interface->writeVersion(versionWriter);
     }
 
     // If the version emitter is empty, version is not available. We can encode
     // this in the dialect ID, so if there is no version, we don't write the
     // section.
     size_t versionAvailable = versionEmitter.size() > 0;
     dialectEmitter.emitVarIntWithFlag(nameID, versionAvailable);
void BytecodeWriter::writeAttrTypeSection(EncodingEmitter &emitter) {
   uint64_t prevOffset = 0;
   auto emitAttrOrType = [&](auto &entry) {
     auto entryValue = entry.getValue();
 
     // First, try to emit this entry using the dialect bytecode interface.
     bool hasCustomEncoding = false;
     if (const BytecodeDialectInterface *interface = entry.dialect->interface) {
       // The writer used when emitting using a custom bytecode encoding.
-      DialectWriter dialectWriter(attrTypeEmitter, numberingState,
-                                  stringSection);
+      DialectWriter dialectWriter(config.bytecodeVersion, attrTypeEmitter,
+                                  numberingState, stringSection);
 
       if constexpr (std::is_same_v<std::decay_t<decltype(entryValue)>, Type>) {
         // TODO: We don't currently support custom encoded mutable types.
         hasCustomEncoding =
             !entryValue.template hasTrait<TypeTrait::IsMutable>() &&
             succeeded(interface->writeType(entryValue, dialectWriter));
       } else {
         // TODO: We don't currently support custom encoded mutable attributes.

 
 private:
   EncodingEmitter &emitter;
   StringSectionBuilder &stringSection;
   PostProcessFn postProcessFn;
 };
 } // namespace
 
-void BytecodeWriter::writeResourceSection(
-    Operation *op, EncodingEmitter &emitter,
-    const BytecodeWriterConfig::Impl &config) {
+void BytecodeWriter::writeResourceSection(Operation *op,
+                                          EncodingEmitter &emitter) {
   EncodingEmitter resourceEmitter;
   EncodingEmitter resourceOffsetEmitter;
   uint64_t prevOffset = 0;
   SmallVector<std::tuple<StringRef, AsmResourceEntryKind, uint64_t>>
       curResourceEntries;
 
   // Functor used to process the offset for a resource of `kind` defined by
   // 'key'.
void BytecodeWriter::writeStringSection(EncodingEmitter &emitter) {
   EncodingEmitter stringEmitter;
   stringSection.write(stringEmitter);
   emitter.emitSection(bytecode::Section::kString, std::move(stringEmitter));
 }
 
 //===----------------------------------------------------------------------===//
 // Entry Points
 //===----------------------------------------------------------------------===//
 
-void mlir::writeBytecodeToFile(Operation *op, raw_ostream &os,
-                               const BytecodeWriterConfig &config) {
-  BytecodeWriter writer(op);
-  writer.write(op, os, config.getImpl());
+BytecodeWriterResult
+mlir::writeBytecodeToFile(Operation *op, raw_ostream &os,
+  BytecodeWriter writer(op, config.getImpl());
+  writer.write(op, os);
+  // Return the bytecode version emitted - currently there is no additional
+  // feedback as to minimum beyond the requested one.
+  return {config.getImpl().bytecodeVersion};
 }

mlir/lib/Bytecode/Writer/IRNumbering.cpp

 //===- IRNumbering.cpp - MLIR Bytecode IR numbering -----------------------===//
 //
 // 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 "IRNumbering.h"
+#include "../Encoding.h"
 #include "mlir/Bytecode/BytecodeImplementation.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace mlir;
 using namespace mlir::bytecode::detail;
 
 //===----------------------------------------------------------------------===//
 // NumberingDialectWriter
 //===----------------------------------------------------------------------===//
 
struct IRNumberingState::NumberingDialectWriter : public DialectBytecodeWriter {
   void writeAPFloatWithKnownSemantics(const APFloat &value) override {}
   void writeOwnedString(StringRef) override {
     // TODO: It might be nice to prenumber strings and sort by the number of
     // references. This could potentially be useful for optimizing things like
     // file locations.
   }
   void writeOwnedBlob(ArrayRef<char> blob) override {}
 
+  int64_t getBytecodeVersion() const override {
+    llvm_unreachable("unexpected querying of version in IRNumbering");
+  }
+
   /// The parent numbering state that is populated by this writer.
   IRNumberingState &state;
 };
 
 //===----------------------------------------------------------------------===//
 // IR Numbering
 //===----------------------------------------------------------------------===//
 

mlir/lib/CAPI/IR/IR.cpp

void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
   unwrap(flags)->useLocalScope();
 }
 
 void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags) {
   unwrap(flags)->assumeVerified();
 }
 
 //===----------------------------------------------------------------------===//
+// Bytecode printing flags API.
+//===----------------------------------------------------------------------===//
+
+MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate() {
+  return wrap(new BytecodeWriterConfig());
+}
+
+void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config) {
+  delete unwrap(config);
+}
+
+void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
+                                                int64_t version) {
+  unwrap(flags)->setDesiredBytecodeVersion(version);
+}
+
+//===----------------------------------------------------------------------===//
 // Location API.
 //===----------------------------------------------------------------------===//
 
 MlirAttribute mlirLocationGetAttribute(MlirLocation location) {
   return wrap(LocationAttr(unwrap(location)));
 }
 
 MlirLocation mlirLocationFromAttribute(MlirAttribute attribute) {

 }
 
 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
                                  MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream, *unwrap(flags));
 }
 
-void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback,
+MlirBytecodeWriterResult mlirOperationWriteBytecode(MlirOperation op,
+                                                    MlirStringCallback callback,
                                                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
-  writeBytecodeToFile(unwrap(op), stream);
+  MlirBytecodeWriterResult res;
+  BytecodeWriterResult r = writeBytecodeToFile(unwrap(op), stream);
+  res.minVersion = r.minVersion;
+  return res;
+}
+
+MlirBytecodeWriterResult mlirOperationWriteBytecodeWithConfig(
+    MlirOperation op, MlirBytecodeWriterConfig config,
+    MlirStringCallback callback, void *userData) {
+  detail::CallbackOstream stream(callback, userData);
+  BytecodeWriterResult r =
+      writeBytecodeToFile(unwrap(op), stream, *unwrap(config));
+  MlirBytecodeWriterResult res;
+  res.minVersion = r.minVersion;
+  return res;
 }
 
 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
 
 bool mlirOperationVerify(MlirOperation op) {
   return succeeded(verify(unwrap(op)));
 }
 

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

 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 using namespace llvm;
 
 namespace {
+class BytecodeVersionParser : public cl::parser<std::optional<int64_t>> {
+public:
+  BytecodeVersionParser(cl::Option &O)
+      : cl::parser<std::optional<int64_t>>(O) {}
+
+  bool parse(cl::Option &O, StringRef /*argName*/, StringRef arg,
+             std::optional<int64_t> &v) {
+    long long w;
+    if (getAsSignedInteger(arg, 10, w))
+      return O.error("Invalid argument '" + arg +
+                     "', only integer is supported.");
+    v = w;
+    return false;
+  }
+};
+
 /// This class is intended to manage the handling of command line options for
 /// creating a *-opt config. This is a singleton.
 struct MlirOptMainConfigCLOptions : public MlirOptMainConfig {
   MlirOptMainConfigCLOptions() {
     // These options are static but all uses ExternalStorage to initialize the
     // members of the parent class. This is unusual but since this class is a
     // singleton it basically attaches command line option to the singleton
     // members.
 
     static cl::opt<bool, /*ExternalStorage=*/true> allowUnregisteredDialects(
         "allow-unregistered-dialect",
         cl::desc("Allow operation with no registered dialects"),
         cl::location(allowUnregisteredDialectsFlag), cl::init(false));
 
     static cl::opt<bool, /*ExternalStorage=*/true> dumpPassPipeline(
         "dump-pass-pipeline", cl::desc("Print the pipeline that will be run"),
         cl::location(dumpPassPipelineFlag), cl::init(false));
 
     static cl::opt<bool, /*ExternalStorage=*/true> emitBytecode(
         "emit-bytecode", cl::desc("Emit bytecode when generating output"),
         cl::location(emitBytecodeFlag), cl::init(false));
 
+    static cl::opt<std::optional<int64_t>, /*ExternalStorage=*/true,
+                   BytecodeVersionParser>
+        bytecodeVersion(
+            "emit-bytecode-version",
+            cl::desc("Use specified bytecode when generating output"),
+            cl::location(emitBytecodeVersion), cl::init(std::nullopt));
+
     static cl::opt<std::string, /*ExternalStorage=*/true> irdlFile(
         "irdl-file",
         cl::desc("IRDL file to register before processing the input"),
         cl::location(irdlFileFlag), cl::init(""), cl::value_desc("filename"));
 
     static cl::opt<bool, /*ExternalStorage=*/true> enableDebuggerHook(
         "mlir-enable-debugger-hook",
         cl::desc("Enable Debugger hook for debugging MLIR Actions"),
performActions(raw_ostream &os,
   // Run the pipeline.
   if (failed(pm.run(*op)))
     return failure();
 
   // Print the output.
   TimingScope outputTiming = timing.nest("Output");
   if (config.shouldEmitBytecode()) {
     BytecodeWriterConfig writerConfig(fallbackResourceMap);
+    if (auto v = config.bytecodeVersionToEmit()) {
+      writerConfig.setDesiredBytecodeVersion(*v);
+      // Returns failure if requested version couldn't be used for opt tools.
+      return success(
+          writeBytecodeToFile(op.get(), os, writerConfig).minVersion <= *v);
+    }
     writeBytecodeToFile(op.get(), os, writerConfig);
-  } else {
-    AsmState asmState(op.get(), OpPrintingFlags(), /*locationMap=*/nullptr,
-                      &fallbackResourceMap);
-    op.get()->print(os, asmState);
-    os << '\n';
-  }
+    return success();
+  }
+
+  if (config.bytecodeVersionToEmit().has_value())
+    return emitError(UnknownLoc::get(pm.getContext()))
+           << "bytecode version while not emitting bytecode";
   return success();
 }
 
 LogicalResult loadIRDLDialects(StringRef irdlFile, MLIRContext &ctx) {
   DialectRegistry registry;
   registry.insert<irdl::IRDLDialect>();
   ctx.appendDialectRegistry(registry);
 

mlir/test/Bytecode/versioning/versioned_bytecode.mlir

+// This file contains test cases related to roundtripping.
+
+// Bytecode currently does not support big-endian platforms
+// UNSUPPORTED: target=s390x-{{.*}}
+
+//===--------------------------------------------------------------------===//
+// Test roundtrip
+//===--------------------------------------------------------------------===//
+
+// RUN: mlir-opt %S/versioned-op-1.12.mlirbc -emit-bytecode \
+// RUN:   -emit-bytecode-version=0 | mlir-opt -o %t.1 && \
+// RUN: mlir-opt %S/versioned-op-1.12.mlirbc -o %t.2 && \
+// RUN: diff %t.1 %t.2
+

mlir/test/python/ir/operation.py

def testOperationPrint():
   # CHECK: return %arg0 : i32
   module.operation.print(file=f)
   str_value = f.getvalue()
   print(str_value.__class__)
   print(f.getvalue())
 
   # Test roundtrip to bytecode.
   bytecode_stream = io.BytesIO()
-  module.operation.write_bytecode(bytecode_stream)
+  result = module.operation.write_bytecode(bytecode_stream, desired_version=1)
+  assert result.min_version() == 1, "Requested version not serialized to"
   bytecode = bytecode_stream.getvalue()
   assert bytecode.startswith(b'ML\xefR'), "Expected bytecode to start with MLïR"
   module_roundtrip = Module.parse(bytecode, ctx)
   f = io.StringIO()
   module_roundtrip.operation.print(file=f)
   roundtrip_value = f.getvalue()
   assert str_value == roundtrip_value, "Mismatch after roundtrip bytecode"