Extension of "Implement IR versioning through post-parsing upgrade through OpAsmDialectInterface"

[mfrancio]

Summary

[mlir] Implements IR versioning capability

A dialect can opt-in to handle versioning through the BytecodeDialectInterface. Few hooks are exposed to the dialect to allow managing a version encoded into the bytecode file. The version is loaded lazily and allows to retrieve the version information while parsing the input IR, and gives an opportunity to each dialect for which a version is present to perform IR upgrades post-parsing through the upgradeFromVersion method. Custom Attribute and Type encodings can also be upgraded according to the dialect version using readAttribute and readType methods.

There is no restriction on what kind of information a dialect is allowed to encode to model its versioning. Currently, versioning is supported only for bytecode formats.

[myhsu]

My Phab handle is different from my Discourse account

[jpienaar]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1466

I'd prefer upgrade of the in memory structure to not be inside the reader. We already have a way to parse without verification, this upgrade is of the in memory structure which can be done separate. In here I'd prefer only upgrades related to parsing/before it gets to memory. This could be done at the top level entry point though, but outside of the parsing guts feels.

mlir/lib/IR/AsmPrinter.cpp

3091

When this was discussed we talked about needing to have builtin attr version be treated specially (else one can't parse its version to know how to parse integerattr even).

mlir/test/lib/Dialect/Test/TestDialect.cpp

176

Note: error messages should follow LLVM convention and be a sentence fragment (start lower case, no trailing punctuation)

1675

I may have missed where this is used.

[myhsu]

I believe some tests are missing like those related to bytecode. Also could you attach diff with more context as instructed here.

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

504

format: add braces

[mfrancio]

Revised diff according to the comments received:

• Adds a new built-in "VersionAttr";
• Decouples VersionAttr from other built-in Attributes, so that they can grow independently;
• Leaves complete freedom to each dialect on how to manage versioning and how to encode its version into the VersionAttr;
• Exposes a couple of hooks to optionally print/parse the dialect version as custom string.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1466

I considered this, but I found a little bit confusing the need to carry over the version at which the IR was parsed into the top level entry point - I actually like a lot the fact that the version stays within the parsing, so that only the current version of the dialect exists at the entry point level.

mlir/lib/IR/AsmPrinter.cpp

3091

I added a new built in attribute called VersionAttr.

mlir/test/lib/Dialect/Test/TestDialect.cpp

1675

Yes, indeed I forgot to upload the corresponding mlir file.

[mehdi_amini]

I don't understand why we need a builtin VersionAttr at all?

[mehdi_amini]

In D143647#4135740, @mehdi_amini wrote:

I don't understand why we need a builtin VersionAttr at all?

Nevermind, this is just lifetime management, doesn't seem unreasonable.

[rriddle]

Haven't had time to dig in here, but adding an attribute doesn't feel right for version. Why is this necessary? As opposed to being something specific to the assembly format?

[mfrancio]

In D143647#4135778, @rriddle wrote:

Haven't had time to dig in here, but adding an attribute doesn't feel right for version. Why is this necessary? As opposed to being something specific to the assembly format?

Quoting @jpienaar: "When this was discussed we talked about needing to have builtin attr version be treated specially (else one can't parse its version to know how to parse integerattr even)."

One of the comments I received in the first version was indeed to use a new builtin attr that could be treated specially and allow decoupling with the existing attributes. Also, we wish to encode anything on the version and leave freedom to each dialect to do whatever (essentially writing on/retrieving the buffer). It indeed felt natural to use a new attribute that handles that bag of bytes. I would be happy to revise as necessary if there is a better solution to do this.

[mehdi_amini]

In D143647#4135778, @rriddle wrote:

Haven't had time to dig in here, but adding an attribute doesn't feel right for version. Why is this necessary? As opposed to being something specific to the assembly format?

I was thinking about how to manage the lifetime, but I think the attribute does not change much actually: a handle still need to be made available whether it is an attribute or not.
So we could design it with a data structure stored on the parser itself and so made available to the dialects during the parsing.
It wouldn't survive the parsing phase though: post-parsing you lose the information about the version producer.

[mfrancio]

In D143647#4135978, @mehdi_amini wrote:

In D143647#4135778, @rriddle wrote:

Haven't had time to dig in here, but adding an attribute doesn't feel right for version. Why is this necessary? As opposed to being something specific to the assembly format?

I was thinking about how to manage the lifetime, but I think the attribute does not change much actually: a handle still need to be made available whether it is an attribute or not.
So we could design it with a data structure stored on the parser itself and so made available to the dialects during the parsing.
It wouldn't survive the parsing phase though: post-parsing you lose the information about the version producer.

In the current implementation you don't really need to have a lifetime that exceeds the parsing. However, this may change in the future and having a reserved attribute for doing this may come handy. Are there any other drawbacks I do not see for adding a VersionAttr? If there are, I would be more than happy to revise further with the idea of adding a parser data structure. Any additional feedback would be greatly appreciated.

[mfrancio]

In the hope of reaching consensus, I am uploading a revised diff that removes the use of attributes entirely for Version and introduces a new dedicated AsmDialectVersionHandle to manage the lifetime of the buffer.

To summarize, the proposed approach:

• Introduces a new AsmDialectVersionHandle to manage the lifetime of buffer representing dialect attribute info;
• decouples versioning of a dialect to the rest of the mlir infrastructure, so each can be used and grow independently;
• Leaves complete freedom to each dialect on how to manage versioning and how to encode its version into the Version Handle;
• Exposes a couple of hooks to optionally print/parse the dialect version as custom string.

I hope you will find this interesting and compelling for the project.

[saksenadhruv]

In D143647#4135778, @rriddle wrote:

Haven't had time to dig in here, but adding an attribute doesn't feel right for version. Why is this necessary? As opposed to being something specific to the assembly format?

Have we successfully addressed the concern here and is this ready to land?

[mehdi_amini]

I just skimmed through, I'd need some time to review this but I'm travelling right now and not sure if I'll get to it before the week end.

My intuition right now would be to implement it only for the Bytecode for now. The story there is more comprehensive than for the textual format, where we only offer the post-parsing upgrade and no control during parsing (and I'm not convinced we should encourage this).

Something that would be nice also is an example of how to use the version while parsing a type or an attribute to support an upgraded format (for example a new field that was added post version 1.40 or something like that).

mlir/include/mlir/IR/OpImplementation.h

470

Can you increase the amount of doc here: add context about what purpose it serves and some info on the context where it is used.

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1461

Can you spell the type here?

1466

Should byteCodedialect.dialect be available here?

1470

Isn't dyn_cast working for dialect interfaces?

1729

Is going through the string name for the dialect the best way to resolve this? (I would think we have a dialect ID directly available? And using integer makes everything else more straighforward)

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

We should use the bytecode encoding here for portability purpose at minima.
That is encore the two int as varint (and decode them when loading).

mlir/test/lib/Dialect/Test/TestOps.td

3171

Leftover?

[rriddle]

In addition to the stuff mentioned, I'd also love to see top-level docs detailing versioning, how it's structured, and how to hook in.

mlir/test/lib/Dialect/Test/TestOps.td

3170–3171

Dead code?

[mfrancio]

In D143647#4144867, @rriddle wrote:

In addition to the stuff mentioned, I'd also love to see top-level docs detailing versioning, how it's structured, and how to hook in.

Thanks for your feedback. I will also add some tests related to the byte code encoding itself, similarly to what already done for the other sections -- I've been holding off to doing it while trying to get the bulk of the code reviewed.

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1461

definitely.

1466

Yes, it should, but it looks like you would have to handle a bunch of cases in the general case.

From BytecodeDialect.h:

/// The loaded dialect entry. This field is std::nullopt if we haven't
/// attempted to load, nullptr if we failed to load, otherwise the loaded
/// dialect.
std::optional<Dialect *> dialect;

I find getting the dialect from the context directly to be generally safer here.

1470

Yes, it does work - are there any issues in using this API though?

I'll change it anyway, since we could dyn_cast_or_null and remove the check for nullptr on the dialect.

1729

It is true that the bytecode holds an integer which references the string section, but I don't see an existing API to reference the string by idx.

I don't really see the "non-straightforward" part anyway - we parse a string with a clean API, and we use it as a hash to map to the version handle. Am I missing something?

mlir/test/lib/Dialect/Test/TestOps.td

3170–3171

yep. thanks for pointing it out!

[mfrancio]

mlir/include/mlir/IR/OpImplementation.h

470

Definitely.

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

This is a very good point that I overlooked.

It looks like we have two separate problems here - one is the portability, and the other one is to apply some sort of compression (not really critical in my view, but nice to have).

For the purpose of the example, the first problem could be solved simply by using the helpers exposed by llvm under llvm/Support/Endian.h. For example, we could write/read the integers representing the version using

inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
inline uint16_t read16le(const void *P) { return read16<little>(P); }

For the second, using varInt is definitely a great idea. It would be great to reuse the same byte code emitters and readers but it looks like they are not really exposed outside the bytecode cpp files. What we could do is to expose the varInt portion of it as helpers under mlir/Support. I am open to doing it, but since this is just an example, is it really worth it?

Looking forward to hear your thoughts.

[mfrancio]

Updates with respect to the previous diff:

• Removes versioning capabilities from the textual format
• Adds new tests specific to the bytecode format
• Adds some documentation and addresses some comments

To summarize, the proposed approach:

• Introduces a new AsmDialectVersionHandle to manage the lifetime of buffer representing dialect attribute info;
• decouples versioning of a dialect to the rest of the mlir infrastructure, so each can be used and grow independently;
• Leaves complete freedom to each dialect on how to manage versioning and how to encode its version into the Version Handle.

Looking forward to your feedback.

[mehdi_amini]

Going in the right direction, thanks for the update!

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Efficiency: string manipulation isn't free.

That said it is pretty bounded here, we should have at most one version per dialect...

But stepping back: why aren't we emitting the version in the dialect section?
We could emit an varint for the version blob size, if it is zero that means there is no version attached to the dialect.
That seems like it could fit right before the op names.

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

The bytecode primitive are exposed in the public header mlir/include/mlir/Bytecode/BytecodeImplementation.h.

Have a look at the dialect interface for manipulating types and attribute:

virtual Attribute readAttribute(DialectBytecodeReader &reader) const {

We should model the API here similarly: for a dialect writing a custom version blob should be no different than writing an attribute.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

The reason why I didn't do it is that it would break existing bytecodes and would require increasing the bytecode version (I am talking about mlir::bytecode::kVersion). I am open to this, but I don't really see the immediate need. It could always be done as part of a major update of the bytecode version itself.

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

Sounds good, I'll take a look.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

In general I'm not in favor of taking detour when we know where we want to land (I don't see a problem with upgrading the bytecode as a breaking change at this point). There are a couple of things I intend to break there as well soon-ish.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Maybe this was already discussed in the past and I missed it, but isn't the bytecode version itself going to be backward compatible? Is there any interest in achieving this?

[saksenadhruv]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Yes, we actually are hoping to ship a serialization format with versioning soon, and would like bytecode to have some compatibility, or atleast a way to upgrade/downgrade when we break it in next couple of months.

What is the guidance on using bytecode for serialization and compatibility?

We are using versioning on our dialect but we need some underlying guarantees on the bytecode itself as well.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Yes we want it to be stable. From my point of view I am aware of 3 features I want to get before I'm comfortable with trying to claim that we reached the "stability" point.

• Dialect Versioning (thanks you for driving this!)
• Use-list order.
• Lazy-loading ability.

(Some people may have other ideas, I'm not aware of any)

Then there is my work on "properties", but I suspect we can preserve backward compatibility on this (assuming the dialects themselves don't change of course).

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Back to:

We could emit an varint for the version blob size, if it is zero that means there is no version attached to the dialect.
That seems like it could fit right before the op names.

If we are in agreement on the current proposal (the dialect provides a version handle which holds a buffer to be written to file), we can definitely emit this blob of data into the dialect section as a breaking change. Can you kindly confirm before I move forward with the change?

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

I considered this, but I don't really see a way to model the API for reading and writing a version into the dialect section through what is exposed in BytecodeImplementation.h. That dialect interface seem to have very specific objectives that are tied to writing and reading custom attributes and types into their respective sections - what we need is an interface that allows the dialect to write into a custom buffer. We could model the API through this interface, but it would become something pretty close to EncodingEmitter implemented in mlir/lib/Bytecode/Writer/BytecodeWriter.cpp, line 64. Wouldn't it be just more convenient to expose something like this under Support?

It is true that writing a blob of data is no different than writing an attribute, but what changes here is the way this blob of data is created. For the attribute, its encoding is defined. But since we want to be independent from any existing attribute, and also completely defined by the user, I don't really see another convenient way of doing this other than exposing low level API to the user to write whatever encoding they need into their data blob that they wish to use to represent the version.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Yes I think we should just do that now if we need to, that said in https://reviews.llvm.org/D145328 I did the change in a backward compatible way.

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

I considered this, but I don't really see a way to model the API for reading and writing a version into the dialect section through what is exposed in BytecodeImplementation.h. That dialect interface seem to have very specific objectives that are tied to writing and reading custom attributes and types into their respective sections

Right, sorry if I have the impression that this interface was "ready to be used" as-is here, I meant to point it as an example of an API that allows dialect author to access bytecode manipulation primitives.

what we need is an interface that allows the dialect to write into a custom buffer. We could model the API through this interface, but it would become something pretty close to EncodingEmitter implemented in mlir/lib/Bytecode/Writer/BytecodeWriter.cpp, line 64. Wouldn't it be just more convenient to expose something like this under Support?
It is true that writing a blob of data is no different than writing an attribute, but what changes here is the way this blob of data is created. For the attribute, its encoding is defined. But since we want to be independent from any existing attribute, and also completely defined by the user, I don't really see another convenient way of doing this other than exposing low level API to the user to write whatever encoding they need into their data blob that they wish to use to represent the version.

I started typing a long answer here, but felt like I was missing something so I sketched something here instead: https://reviews.llvm.org/D145328

(there is still a bug, and a I haven't regenerated the bytecode test file, but the interface is there!)

[jpienaar]

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

I like the sketch.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Yes! This is exactly what I envisioned when I started implementing the first draft, but I didn't post it as I didn't want to rely on a bytecode version change. Nice to see this.

We could also opt to remove the version section explicitly and inline the read/write of size/bytes reusing the alignment of the parent dialect section (probably a bit more memory efficient), but this works.

mlir/test/lib/Dialect/Test/TestDialect.cpp

63

Thanks for the suggestion. This is very neat, I'll try to finalize it and regenerate the bytecode test files.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

The reason I used a section is that when we load the version section we haven't loaded the dialect yet so we don't have the interface.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Something to add still is an attribute in the test dialect that is serialized at v0.1 and read / upgraded during parsing of v0.2.
I suspect we're missing making the version available on the readAttribute API.

[mfrancio]

Updates diff incorporating changes from https://reviews.llvm.org/D145328

Includes an example for upgrading an attribute that was written at v1 and it is read at v2 with a different encoding.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

I did the change! It is tested only for attributes, but I can easily extend it to types as well!

1729

The reason I used a section is that when we load the version section we haven't loaded the dialect yet so we don't have the interface.

I still don't see the reason. I think the section could just be inlined. You don't need the interface to read it (we would just hold the buffer). The interface is needed later to resolve the buffer and decode it... Unless I am missing something subtle :)

[mehdi_amini]

LGTM, but please wait for @rriddle to stamp it as well!

mlir/include/mlir/Bytecode/BytecodeImplementation.h

324 ↗

(On Diff #502915)

Can you add a simple doc?

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Right, I guess I didn't find the method to do it!

Do you see how to emit the content of the versionEmitter differently than using emitSection? We need to emit the size and then the content. The logic in emitSection() has this logic:

// Push our current buffer and then merge the provided section body into
// ours.
appendResult(std::move(currentResult));
for (std::vector<uint8_t> &result : emitter.prevResultStorage)
  prevResultStorage.push_back(std::move(result));
llvm::append_range(prevResultList, emitter.prevResultList);
prevResultSize += emitter.prevResultSize;
appendResult(std::move(emitter.currentResult));

(knowing that the writeVersion interface can't do it because it needs to compute the size first before emitting the content)

mlir/test/lib/Dialect/Test/TestDialect.cpp

124

Would else be enough here?

[rriddle]

Looking very close, thanks!

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

Why use a separate section? I would have expected to have this just be part of the op_name_group (which should be renamed at this point to dialect). We can store a bit with numOpNames or dialect to indicate if a version is present, and then optionally read it.

mlir/include/mlir/Bytecode/BytecodeImplementation.h

320–322 ↗

(On Diff #502915)

Why is it necessary for dialect authors to write the size? I would expect this could be automatically handled (e.g. via back-patching)?

mlir/include/mlir/IR/OpImplementation.h

1458–1460

This change feels unrelated, can you revert?

[jpienaar]

Nice! I'm fine with delaying textual form.

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

I don't think it's documented here, can we have multiple op_name_groups for same dialect? With the naming change it feels like it's saying there will be only one per dialect.

+1 to bit and making this optionally specified if bit set. (I think section may be overloaded, I see this as proposed as just convenient way of grouping these two optional items together).

mlir/include/mlir/Bytecode/BytecodeImplementation.h

275 ↗

(On Diff #502915)

If we have a versioned dialect, it would seem we'd always have to use this method just in case (and if version is unspecified then there is just no upgrade).

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

430

Why does DialectReader need to be thread through? I thought it was a rather cheap, stateless structure to create.

[mfrancio]

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

Agreed, I'll plan for this change.

You shouldn't really need a bit - just printing the buffer is enough. A size zero means that no version is available.

From a quick look I don't think you can have multiple op_name_groups per dialect - those are indeed already grouped by dialect:

// Parse the operation names, which are grouped by dialect.
auto parseOpName = [&](BytecodeDialect *dialect) {
  StringRef opName;
  if (failed(stringReader.parseString(sectionReader, opName)))
    return failure();
  opNames.emplace_back(dialect, opName);
  return success();
};
while (!sectionReader.empty())
  if (failed(parseDialectGrouping(sectionReader, dialects, parseOpName)))
    return failure();

so changing the op_name_group to be dialect itself should be fine.

mlir/include/mlir/Bytecode/BytecodeImplementation.h

275 ↗

(On Diff #502915)

I feel it's anyway up to the dialect to decide what to do here. Having a fall-back seems convenient to me, but if it looks confusing or there is desire to push for the versioned implementation anyway we can emit an error similarly to the other reader.

320–322 ↗

(On Diff #502915)

This slipped - it is indeed not necessary. I'll update the comment.

mlir/include/mlir/IR/OpImplementation.h

1458–1460

Sure!

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

Exactly, I was thinking of consolidating this into a new method of reader and avoid the existence of a new dialect version section. I'll try!

mlir/test/lib/Dialect/Test/TestDialect.cpp

124

I think the comment below is misleading - the intent was to forbid reading a newer than current version. I'll revise this.

[mehdi_amini]

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

We could use a bit on the numOpNames to gate the existence of the version:

op_name_group {
  dialect: varint,
  numOpNamesAndIsVersionAvailable: varint, // (numOpNames << 1 | versionAvailable)
  version : dialect_version_section
  opNames: varint[]
}

That way we don't write a section when there is no version there.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

430

It is cheap, but needs to be created from things unavailable in this class, so you'd need to thread through more of other things here!

[jpienaar]

I was wondering (post review) if we should split the reader and writer commit parts, so that we could give a bit of time for bytecode consumers to get updated first (thinking of projects that span multiple repos). I mean, it is unstable at the moment, but wouldn't cause any additional churn.

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

They are grouped by dialect, but it just emplaces inside a vector. The emplacing results in the "flat" ID, so one can have multiple instances of this where the flat id can be small for the most common operations independent of dialect.

So we'd probably need to just verify that a version is only specified once for a dialect (we could allow multiple as long as the same but that seems undesirable from size poitn of view)

And yes what Mehdi suggested is what River also mentioned.

mlir/include/mlir/Bytecode/BytecodeImplementation.h

275 ↗

(On Diff #502915)

Yes I'm less worried about dialect than checking expectations for bytecode format parser (where it defers to dialect inside attribute/type parser its under full control of dialect).

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

430

What else do you need to thread through? Dialect version?

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

430

Look at the call sites:

DialectReader dialectReader(*this, stringReader, resourceReader, reader);
if (failed(entry.dialect->load(dialectReader, fileLoc.getContext())))
  return failure();

So stringReader, resourceReader are the extra I think?
(also some call sites already have the dialectReader available)

[mfrancio]

Added a bit flag to detect if a dialect is versioned and trigger the read of the section.

[mfrancio]

mlir/docs/BytecodeFormat.md

166–169 ↗

(On Diff #502915)

Added the bit flag. It felt more natural doing it on the dialect name itself instead of going inside the dialect version grouping. Let me know if there are any concerns.

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1729

I considered this again, but the only thing that would eventually "save" is really to print the var int of the section, so it felt not strictly necessary now that we have the bit flag.

[rriddle]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1082

Can you drop the trivial braces here?

1386

I really thought we had a helper that read a varint and extracted a flag.

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1386

Oh indeed, I didn't see it. Thanks!

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1082

yep, thanks!

[mehdi_amini]

LGTM, thanks for being so patient through the reviews!

Let's wait for @rriddle to give a final approval.

[mehdi_amini]

In D143647#4185686, @mehdi_amini wrote:

LGTM, thanks for being so patient through the reviews!

Let's wait for @rriddle to give a final approval.

Actually River reviewed already (I starting reviewing earlier and went out, figured I didn't hit "submit" before).

[mehdi_amini]

Do you have commit access or do you need help to land this?

[mfrancio]

In D143647#4185691, @mehdi_amini wrote:

Do you have commit access or do you need help to land this?

I don't have commit access, it's the first time I commit here! I was just waiting for the builds to complete before asking for help.

Thank you all for the feedback - it's been nice to collaborate!

[mehdi_amini]

Right now you have test failures. On my Mac locally I see:

Failed Tests (2):
  MLIR :: Bytecode/versioning/versioned_attr.mlir
  MLIR :: Bytecode/versioning/versioned_op.mlir

mlir/include/mlir/IR/Builders.h

public:
   template <typename Attr, typename... Args>
   Attr getAttr(Args &&...args) {
     return Attr::get(context, std::forward<Args>(args)...);
   }
 
   // Attributes.
   NamedAttribute getNamedAttr(StringRef name, Attribute val);
 
+  VersionAttr getVersionAttr(ArrayRef<uint8_t> data);
   UnitAttr getUnitAttr();
   BoolAttr getBoolAttr(bool value);
   DictionaryAttr getDictionaryAttr(ArrayRef<NamedAttribute> value);
   IntegerAttr getIntegerAttr(Type type, int64_t value);
   IntegerAttr getIntegerAttr(Type type, const APInt &value);
   FloatAttr getFloatAttr(Type type, double value);
   FloatAttr getFloatAttr(Type type, const APFloat &value);
   StringAttr getStringAttr(const Twine &bytes);

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     func.func @simple_form() attributes {dialectName.unitAttr}
     ```
   }];
   let extraClassDeclaration = [{
     static UnitAttr get(MLIRContext *context);
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// VersionAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_VersionAttrRawDataParameter : ArrayRefParameter<
+    "uint8_t", "storage for version attribute"> {
+  let allocator = [{
+    if (!$_self.empty()) {
+      auto *alloc = static_cast<uint8_t *>(
+          $_allocator.allocate($_self.size(), 1));
+      std::uninitialized_copy($_self.begin(), $_self.end(), alloc);
+      $_dst = ArrayRef<uint8_t>(alloc, $_self.size());
+    }
+  }];
+}
+
+def Builtin_VersionAttr : Builtin_Attr<"Version"> {
+  let summary = "An Attribute containing a blob of data representing a version";
+  let description = [{
+    A version attribute is an attribute that represents a blob of data managed
+    by each dialect independently. It is responsability of the dialect to define
+    a proper dialect version format and encode/decode it into/from this
+    attribute.
+
+    Syntax:
+
+    ```
+    version-attribute ::= `version` `<` (attribute-value) `>`
+    ```
+    Examples:
+
+    ```mlir
+    version<"0x1A">
+    ```
+  }];
+
+  let parameters = (ins Builtin_VersionAttrRawDataParameter:$rawData);
+
+  let extraClassDeclaration = [{
+    /// Get the size of the data blob.
+    size_t size() const { return getRawData().size(); }
+  }];
+}
+
 #endif // BUILTIN_ATTRIBUTES

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual ~AsmParser();
 
   MLIRContext *getContext() const;
 
   /// Return the location of the original name token.
   virtual SMLoc getNameLoc() const = 0;
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emit a diagnostic at the specified location and return failure.
   virtual InFlightDiagnostic emitError(SMLoc loc,
                                        const Twine &message = {}) = 0;
 
   /// Return a builder which provides useful access to MLIRContext, global
   /// objects like types and attributes.
   virtual Builder &getBuilder() const = 0;
 
   /// Get the location of the next token and store it into the argument.  This
   /// always succeeds.
   virtual SMLoc getCurrentLocation() = 0;
   ParseResult getCurrentLocation(SMLoc *loc) {
     *loc = getCurrentLocation();
     return success();
   }
 
   /// Re-encode the given source location as an MLIR location and return it.
   /// Note: This method should only be used when a `Location` is necessary, as
   /// the encoding process is not efficient.
   virtual Location getEncodedSourceLoc(SMLoc loc) = 0;
 
+  /// Return the attribute describing the version of the provided dialect name,
+  /// if any. The version is provided by the `dialect_versions` directive at the
+  /// very beginning of the parsing.
+  virtual VersionAttr getDialectVersion(StringRef dialect) = 0;
+
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a '->' token.
   virtual ParseResult parseArrow() = 0;
 
   /// Parse a '->' token if present
parseAffineExprOfSSAIds(SmallVectorImpl<UnresolvedOperand> &dimOperands,
                           SmallVectorImpl<UnresolvedOperand> &symbOperands,
                           AffineExpr &expr) = 0;
 
   //===--------------------------------------------------------------------===//
   // Argument Parsing
   //===--------------------------------------------------------------------===//
 
   struct Argument {
-    UnresolvedOperand ssaName;    // SourceLoc, SSA name, result #.
-    Type type;                    // Type.
-    DictionaryAttr attrs;         // Attributes if present.
+    UnresolvedOperand ssaName;         // SourceLoc, SSA name, result #.
+    Type type;                         // Type.
+    DictionaryAttr attrs;              // Attributes if present.
     std::optional<Location> sourceLoc; // Source location specifier if present.
   };
 
   /// Parse a single argument with the following syntax:
   ///
   ///   `%ssaName : !type { optionalAttrDict} loc(optionalSourceLoc)`
   ///
   /// If `allowType` is false or `allowAttrs` are false then the respective
public:
   /// end with a numeric digit([0-9]+).
   virtual AliasResult getAlias(Attribute attr, raw_ostream &os) const {
     return AliasResult::NoAlias;
   }
   virtual AliasResult getAlias(Type type, raw_ostream &os) const {
     return AliasResult::NoAlias;
   }
 
+  /// Hook provided by the dialect to emit a version when printing. The
+  /// attribute will be available when parsing back, and the dialect
+  /// implementation will be able to use it to load previous known version.
+  /// This management is entirely under the responsibility of the individual
+  /// dialects, and limited by possible changes in the MLIR syntax.
+  /// There is no restriction on what kind of attribute a dialect is using to
+  /// model its versioning.
+  virtual VersionAttr getProducerVersion() const { return {}; }
+
+  /// Hook invoked after parsing completed, if a version directive was present
+  /// and included an entry for the current dialect. This hook offers the
+  /// opportunity to the dialect to visit the IR and upgrades constructs emitted
+  /// by the version of the dialect corresponding to the provided version
+  /// attribute.
+  virtual LogicalResult upgradeFromVersion(Operation *topLevelOp,
+                                           VersionAttr producerVersion) const {
+    return success();
+  }
+
+  virtual FailureOr<VersionAttr> parseVersionAttr(StringRef token) const {
+    return failure();
+  }
+
+  virtual FailureOr<std::string>
+  printVersionAttrAsString(VersionAttr attr) const {
+    return failure();
+  }
+
   //===--------------------------------------------------------------------===//
   // Resources
   //===--------------------------------------------------------------------===//
 
   /// Declare a resource with the given key, returning a handle to use for any
   /// references of this resource key within the IR during parsing. The result
   /// of `getResourceKey` on the returned handle is permitted to be different
   /// than `key`.

mlir/lib/AsmParser/AsmParserImpl.h

public:
   /// always succeeds.
   SMLoc getCurrentLocation() override { return parser.getToken().getLoc(); }
 
   /// Re-encode the given source location as an MLIR location and return it.
   Location getEncodedSourceLoc(SMLoc loc) override {
     return parser.getEncodedSourceLocation(loc);
   }
 
+  VersionAttr getDialectVersion(StringRef dialect) override {
+    return parser.getDialectVersion(dialect);
+  }
+
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   using Delimiter = AsmParser::Delimiter;
 
   /// Parse a `->` token.
   ParseResult parseArrow() override {

mlir/lib/AsmParser/AttributeParser.cpp

 ///                    | `{` (attribute-entry (`,` attribute-entry)*)? `}`
 ///                    | symbol-ref-id (`::` symbol-ref-id)*
 ///                    | `dense` `<` tensor-literal `>` `:`
 ///                      (tensor-type | vector-type)
 ///                    | `sparse` `<` attribute-value `,` attribute-value `>`
 ///                      `:` (tensor-type | vector-type)
 ///                    | `strided` `<` `[` comma-separated-int-or-question `]`
 ///                      (`,` `offset` `:` integer-literal)? `>`
+///                    | `version` `<` attribute-value `>`
 ///                    | extended-attribute
 ///
 Attribute Parser::parseAttribute(Type type) {
   switch (getToken().getKind()) {
   // Parse an AffineMap or IntegerSet attribute.
   case Token::kw_affine_map: {
     consumeToken(Token::kw_affine_map);
 
Attribute Parser::parseAttribute(Type type) {
   // Parse a sparse elements attribute.
   case Token::kw_sparse:
     return parseSparseElementsAttr(type);
 
   // Parse a strided layout attribute.
   case Token::kw_strided:
     return parseStridedLayoutAttr();
 
+  // Parse a version attribute.
+  case Token::kw_version:
+    return parseVersionAttr();
+
   // Parse a string attribute.
   case Token::string: {
     auto val = getToken().getStringValue();
     consumeToken(Token::string);
     // Parse the optional trailing colon type if one wasn't explicitly provided.
     if (!type && consumeIf(Token::colon) && !(type = parseType()))
       return Attribute();
 
auto parseElt = [&]() -> ParseResult {
 
     // Try to parse the '=' for the attribute value.
     if (!consumeIf(Token::equal)) {
       // If there is no '=', we treat this as a unit attribute.
       attributes.push_back({*nameId, builder.getUnitAttr()});
       return success();
     }
 
-    auto attr = parseAttribute();
+    Attribute attr;
+    if (getToken().is(Token::kw_version))
+      attr = parseVersionAttr(*nameId);
+    else
+      attr = parseAttribute();
     if (!attr)
       return failure();
     attributes.push_back({*nameId, attr});
     return success();
   };
 
   return parseCommaSeparatedList(Delimiter::Braces, parseElt,
                                  " in attribute dictionary");

 }
 
 //===----------------------------------------------------------------------===//
 // TensorLiteralParser
 //===----------------------------------------------------------------------===//
 
 /// Parse elements values stored within a hex string. On success, the values are
 /// stored into 'result'.
-static ParseResult parseElementAttrHexValues(Parser &parser, Token tok,
-                                             std::string &result) {
+static ParseResult parseHexValues(Parser &parser, Token tok,
   if (std::optional<std::string> value = tok.getHexStringValue()) {
     result = std::move(*value);
     return success();
   }
   return parser.emitError(
       tok.getLoc(), "expected string containing hex digits starting with `0x`");
 }
 
DenseElementsAttr TensorLiteralParser::getHexAttr(SMLoc loc, ShapedType type) {
   if (!elementType.isIntOrIndexOrFloat() && !elementType.isa<ComplexType>()) {
     p.emitError(loc)
         << "expected floating-point, integer, or complex element type, got "
         << elementType;
     return nullptr;
   }
 
   std::string data;
-  if (parseElementAttrHexValues(p, *hexStorage, data))
+  if (parseHexValues(p, *hexStorage, data))
     return nullptr;
 
   ArrayRef<char> rawData(data.data(), data.size());
   bool detectedSplat = false;
   if (!DenseElementsAttr::isValidRawBuffer(type, rawData, detectedSplat)) {
     p.emitError(loc) << "elements hex data size is invalid for provided type: "
                      << type;
     return nullptr;
Attribute Parser::parseStridedLayoutAttr() {
   if (!offset || failed(parseToken(Token::greater, "expected '>'")))
     return nullptr;
 
   if (failed(StridedLayoutAttr::verify(errorEmitter, *offset, strides)))
     return nullptr;
   return StridedLayoutAttr::get(getContext(), *offset, strides);
   // return getChecked<StridedLayoutAttr>(loc,getContext(), *offset, strides);
 }
+
+Attribute Parser::parseVersionAttr() {
+  consumeToken(Token::kw_version);
+  if (failed(parseToken(Token::less, "expected '<' after 'version'")))
+    return nullptr;
+
+  if (!getToken().is(Token::string)) {
+    emitWrongTokenError("expected hex string after 'version<'");
+    return nullptr;
+  }
+
+  std::string result;
+  if (failed(parseHexValues(*this, getToken(), result)))
+    return nullptr;
+  consumeToken(Token::string);
+
+  if (failed(parseToken(Token::greater, "expected '>'")))
+    return nullptr;
+
+  llvm::SmallVector<uint8_t> resultCast(result.begin(), result.end());
+  return VersionAttr::get(getContext(), resultCast);
+}
+
+Attribute Parser::parseVersionAttr(StringAttr dialectName) {
+  consumeToken(Token::kw_version);
+  if (failed(parseToken(Token::less, "expected '<' after 'version'")))
+    return nullptr;
+
+  if (!getToken().is(Token::string)) {
+    emitWrongTokenError("expected string after 'version<'");
+    return nullptr;
+  }
+
+  // If the token represents a hex string, parse it as hex.
+  std::string result;
+  if (getToken().getHexStringValue().has_value())
+    if (failed(parseHexValues(*this, getToken(), result)))
+      return nullptr;
+
+  auto *iface = llvm::dyn_cast_or_null<OpAsmDialectInterface>(
+      getContext()->getOrLoadDialect(dialectName));
+  if (result.empty() && !iface)
+    return nullptr;
+
+  // If we couldn't parse the token as hex string, then we can try using the
+  // custom parser exposed to the dialect.
+  VersionAttr attr;
+  if (result.empty()) {
+    FailureOr<VersionAttr> attrOr =
+        iface->parseVersionAttr(getToken().getStringValue());
+    if (succeeded(attrOr))
+      attr = *attrOr;
+    else
+      return nullptr;
+  }
+  consumeToken(Token::string);
+
+  if (failed(parseToken(Token::greater, "expected '>'")))
+    return nullptr;
+
+  if (attr)
+    return attr;
+
+  llvm::SmallVector<uint8_t> resultCast(result.begin(), result.end());
+  return VersionAttr::get(getContext(), resultCast);
+}

mlir/lib/AsmParser/Parser.h

public:
 
   Parser(ParserState &state)
       : builder(state.config.getContext()), state(state) {}
 
   // Helper methods to get stuff from the parser-global state.
   ParserState &getState() const { return state; }
   MLIRContext *getContext() const { return state.config.getContext(); }
   const llvm::SourceMgr &getSourceMgr() { return state.lex.getSourceMgr(); }
+  VersionAttr getDialectVersion(StringRef dialect) const {
+    return state.dialectVersions.get(dialect).cast<VersionAttr>();
+  }
 
   /// Parse a comma-separated list of elements up until the specified end token.
   ParseResult
   parseCommaSeparatedListUntil(Token::Kind rightToken,
                                function_ref<ParseResult()> parseElement,
                                bool allowEmptyList = true);
 
   /// Parse a list of comma-separated items with an optional delimiter.  If a
public:
   Attribute parseDenseArrayAttr(Type type);
 
   /// Parse a sparse elements attribute.
   Attribute parseSparseElementsAttr(Type attrType);
 
   /// Parse a strided layout attribute.
   Attribute parseStridedLayoutAttr();
 
+  /// Parse a version attribute.
+  Attribute parseVersionAttr();
+  Attribute parseVersionAttr(StringAttr dialectName);
+
   //===--------------------------------------------------------------------===//
   // Location Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a raw location instance.
   ParseResult parseLocationInstance(LocationAttr &loc);
 
   /// Parse a callsite location instance.

mlir/lib/AsmParser/Parser.cpp

ParseResult OperationParser::finalize() {
   });
   if (walkRes.wasInterrupted())
     return failure();
 
   // Pop the top level name scope.
   if (failed(popSSANameScope()))
     return failure();
 
+  // Parsing is complete, give an opportunity to each dialect to visit the
+  // IR and perform upgrades.
+  if (state.dialectVersions) {
+    for (NamedAttribute dialectVersion : state.dialectVersions) {
+      Dialect *dialect =
+          getContext()->getLoadedDialect(dialectVersion.getName());
+      if (!dialect)
+        continue;
+      auto *asmIface = dialect->getRegisteredInterface<OpAsmDialectInterface>();
+      if (!asmIface)
+        continue;
+      if (failed(asmIface->upgradeFromVersion(
+              topLevelOp, dialectVersion.getValue().cast<VersionAttr>())))
+        return failure();
+    }
+  }
+
   // Verify that the parsed operations are valid.
   if (state.config.shouldVerifyAfterParse() && failed(verify(topLevelOp)))
     return failure();
 
   // If we are populating the parser state, finalize the top-level operation.
   if (state.asmState)
     state.asmState->finalize(topLevelOp);
   return success();
ParseResult TopLevelOperationParser::parseExternalResourceFileMetadata() {
   });
 }
 
 ParseResult TopLevelOperationParser::parse(Block *topLevelBlock,
                                            Location parserLoc) {
   // Create a top-level operation to contain the parsed state.
   OwningOpRef<ModuleOp> topLevelOp(ModuleOp::create(parserLoc));
   OperationParser opParser(state, topLevelOp.get());
+
+  // If the input starts with a `dialect_versions` keyword, we expect a
+  // dictionary representing the version of the dialect at the time the IR was
+  // produced. This will be used for possibly upgrading the IR when parsing
+  // completes.
+  if (getToken().getSpelling() == "dialect_versions") {
+    consumeToken();
+    Attribute versions = opParser.parseAttribute();
+    if (!versions)
+      return failure();
+    state.dialectVersions = versions.dyn_cast<DictionaryAttr>();
+    if (!state.dialectVersions) {
+      emitError("Expects Dictionary attribute for dialect versions");
+      return failure();
+    }
+  }
+
   while (true) {
     switch (getToken().getKind()) {
     default:
       // Parse a top-level operation.
       if (opParser.parseOperation())
         return failure();
       break;
 

mlir/lib/AsmParser/ParserState.h

struct ParserState {
   AsmParserCodeCompleteContext *codeCompleteContext;
 
   // Contains the stack of default dialect to use when parsing regions.
   // A new dialect get pushed to the stack before parsing regions nested
   // under an operation implementing `OpAsmOpInterface`, and
   // popped when done. At the top-level we start with "builtin" as the
   // default, so that the top-level `module` operation parses as-is.
   SmallVector<StringRef> defaultDialectStack{"builtin"};
+
+  DictionaryAttr dialectVersions;
 };
 
 } // namespace detail
 } // namespace mlir
 
 #endif // MLIR_LIB_ASMPARSER_PARSERSTATE_H

mlir/lib/AsmParser/TokenKinds.def

 TOK_KEYWORD(symbol)
 TOK_KEYWORD(tensor)
 TOK_KEYWORD(to)
 TOK_KEYWORD(true)
 TOK_KEYWORD(tuple)
 TOK_KEYWORD(type)
 TOK_KEYWORD(unit)
 TOK_KEYWORD(vector)
+TOK_KEYWORD(version)
 
 #undef TOK_MARKER
 #undef TOK_IDENTIFIER
 #undef TOK_LITERAL
 #undef TOK_PUNCTUATION
 #undef TOK_KEYWORD

mlir/lib/Bytecode/Encoding.h

enum ID : uint8_t {
 
   /// This section contains the resources of the bytecode.
   kResource = 5,
 
   /// This section contains the offsets of resources within the Resource
   /// section.
   kResourceOffset = 6,
 
+  /// This section contains the versions of each dialect.
+  kDialectVersions = 7,
+
   /// The total number of section types.
-  kNumSections = 7,
+  kNumSections = 8,
 };
 } // namespace Section
 
 //===----------------------------------------------------------------------===//
 // IR Section
 //===----------------------------------------------------------------------===//
 
 /// This enum represents a mask of all of the potential components of an

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

static std::string toString(bytecode::Section::ID sectionID) {
   case bytecode::Section::kAttrTypeOffset:
     return "AttrTypeOffset (3)";
   case bytecode::Section::kIR:
     return "IR (4)";
   case bytecode::Section::kResource:
     return "Resource (5)";
   case bytecode::Section::kResourceOffset:
     return "ResourceOffset (6)";
+  case bytecode::Section::kDialectVersions:
+    return "DialectVersions (7)";
   default:
     return ("Unknown (" + Twine(static_cast<unsigned>(sectionID)) + ")").str();
   }
 }
 
 /// Returns true if the given top-level section ID is optional.
 static bool isSectionOptional(bytecode::Section::ID sectionID) {
   switch (sectionID) {
   case bytecode::Section::kString:
   case bytecode::Section::kDialect:
   case bytecode::Section::kAttrType:
   case bytecode::Section::kAttrTypeOffset:
   case bytecode::Section::kIR:
     return false;
   case bytecode::Section::kResource:
   case bytecode::Section::kResourceOffset:
+  case bytecode::Section::kDialectVersions:
     return true;
   default:
     llvm_unreachable("unknown section ID");
   }
 }
 
 //===----------------------------------------------------------------------===//
 // EncodingReader
LogicalResult load(EncodingReader &reader, MLIRContext *ctx) {
     }
     dialect = loadedDialect;
 
     // If the dialect was actually loaded, check to see if it has a bytecode
     // interface.
     if (loadedDialect)
       interface = dyn_cast<BytecodeDialectInterface>(loadedDialect);
     return success();
   }
 
   /// Return the loaded dialect, or nullptr if the dialect is unknown. This can
   /// only be called after `load`.
   Dialect *getLoadedDialect() const {
     assert(dialect &&
            "expected `load` to be invoked before `getLoadedDialect`");
     return *dialect;
   }
 
   /// The loaded dialect entry. This field is std::nullopt if we haven't
   /// attempted to load, nullptr if we failed to load, otherwise the loaded
   /// dialect.
   std::optional<Dialect *> dialect;
 
   /// The bytecode interface of the dialect, or nullptr if the dialect does not
   /// implement the bytecode interface. This field should only be checked if the
   /// `dialect` field is not std::nullopt.
   const BytecodeDialectInterface *interface = nullptr;
 
   /// The name of the dialect.
   StringRef name;
+
+  VersionAttr version;
 };
 
 /// This struct represents an operation name entry within the bytecode.
 struct BytecodeOperationName {
   BytecodeOperationName(BytecodeDialect *dialect, StringRef name)
       : dialect(dialect), name(name) {}
 
   /// The loaded operation name, or std::nullopt if it hasn't been processed

 
 //===----------------------------------------------------------------------===//
 // Bytecode Reader
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class is used to read a bytecode buffer and translate it into MLIR.
 class BytecodeReader {
 public:
   BytecodeReader(Location fileLoc, const ParserConfig &config,
                  const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef)
       : config(config), fileLoc(fileLoc),
         attrTypeReader(stringReader, resourceReader, fileLoc),
         // Use the builtin unrealized conversion cast operation to represent
         // forward references to values that aren't yet defined.
         forwardRefOpState(UnknownLoc::get(config.getContext()),
                           "builtin.unrealized_conversion_cast", ValueRange(),
FailureOr<Operation *> parseOpWithoutRegions(EncodingReader &reader,
                                                RegionReadState &readState,
                                                bool &isIsolatedFromAbove);
 
   LogicalResult parseRegion(EncodingReader &reader, RegionReadState &readState);
   LogicalResult parseBlock(EncodingReader &reader, RegionReadState &readState);
   LogicalResult parseBlockArguments(EncodingReader &reader, Block *block);
 
   //===--------------------------------------------------------------------===//
+  // Dialect Versions Section
+
+  /// Parse dialect versions.
+  LogicalResult
+  parseDialectVersionsSection(std::optional<ArrayRef<uint8_t>> sectionData);
+
+  //===--------------------------------------------------------------------===//
   // Value Processing
 
   /// Parse an operand reference using the given reader. Returns nullptr in the
   /// case of failure.
   Value parseOperand(EncodingReader &reader);
 
   /// Sequentially define the given value range.
   LogicalResult defineValues(EncodingReader &reader, ValueRange values);
LogicalResult BytecodeReader::read(llvm::MemoryBufferRef buffer, Block *block) {
   if (failed(stringReader.initialize(
           fileLoc, *sectionDatas[bytecode::Section::kString])))
     return failure();
 
   // Process the dialect section.
   if (failed(parseDialectSection(*sectionDatas[bytecode::Section::kDialect])))
     return failure();
 
+  // Process the dialect section.
+  if (failed(parseDialectVersionsSection(
+          sectionDatas[bytecode::Section::kDialectVersions])))
+    return failure();
+
   // Process the resource section if present.
   if (failed(parseResourceSection(
           sectionDatas[bytecode::Section::kResource],
           sectionDatas[bytecode::Section::kResourceOffset])))
     return failure();
 
   // Process the attribute and type section.
   if (failed(attrTypeReader.initialize(
auto parseOpName = [&](BytecodeDialect *dialect) {
     if (failed(stringReader.parseString(sectionReader, opName)))
       return failure();
     opNames.emplace_back(dialect, opName);
     return success();
   };
   while (!sectionReader.empty())
     if (failed(parseDialectGrouping(sectionReader, dialects, parseOpName)))
       return failure();
   return success();
 }
 
 FailureOr<OperationName> BytecodeReader::parseOpName(EncodingReader &reader) {
   BytecodeOperationName *opName = nullptr;
   if (failed(parseEntry(reader, opNames, opName, "operation name")))
     return failure();
 
   // Check to see if this operation name has already been resolved. If we
LogicalResult BytecodeReader::parseIRSection(ArrayRef<uint8_t> sectionData,
   while (!regionStack.empty())
     if (failed(parseRegions(reader, regionStack, regionStack.back())))
       return failure();
   if (!forwardRefOps.empty()) {
     return reader.emitError(
         "not all forward unresolved forward operand references");
   }
 
+  // Resolve dialect version.
+  for (auto dialect : dialects) {
+    // Parsing is complete, give an opportunity to each dialect to visit the
+    // IR and perform upgrades.
+    if (dialect.version) {
+      auto *asmIface =
+          (*dialect.dialect)->getRegisteredInterface<OpAsmDialectInterface>();
+      if (!asmIface)
+        continue;
+      if (failed(asmIface->upgradeFromVersion(*moduleOp, dialect.version)))
+        return failure();
+    }
+  }
+
   // Verify that the parsed operations are valid.
   if (config.shouldVerifyAfterParse() && failed(verify(*moduleOp)))
     return failure();
 
   // Splice the parsed operations over to the provided top-level block.
   auto &parsedOps = moduleOp->getBody()->getOperations();
   auto &destOps = block->getOperations();
   destOps.splice(destOps.end(), parsedOps, parsedOps.begin(), parsedOps.end());
while (numArgs--) {
 
     argTypes.push_back(argType);
     argLocs.push_back(argLoc);
   }
   block->addArguments(argTypes, argLocs);
   return defineValues(reader, block->getArguments());
 }
 
+//===--------------------------------------------------------------------===//
+// Dialect Versions Section
+
+LogicalResult BytecodeReader::parseDialectVersionsSection(
+    std::optional<ArrayRef<uint8_t>> sectionData) {
+  // If the dialect versions are absent, there is nothing to do.
+  if (!sectionData.has_value())
+    return success();
+
+  EncodingReader sectionReader(sectionData.value(), fileLoc);
+
+  // Parse the number of dialects in the section.
+  uint64_t numVersionedDialects;
+  if (failed(sectionReader.parseVarInt(numVersionedDialects)))
+    return failure();
+
+  // Parse each of the dialect versions.
+  llvm::StringMap<VersionAttr> versionedDialectMap;
+  for (uint64_t i = 0; i < numVersionedDialects; ++i) {
+    StringRef dialectName;
+    uint64_t dialectVersionAttrSize;
+    if (failed(stringReader.parseString(sectionReader, dialectName)))
+      return failure();
+    if (failed(sectionReader.parseVarInt(dialectVersionAttrSize)))
+      return failure();
+    ArrayRef<uint8_t> bytes;
+    if (failed(sectionReader.parseBytes(dialectVersionAttrSize, bytes)))
+      return failure();
+    versionedDialectMap.insert(
+        {dialectName, VersionAttr::get(getContext(), bytes)});
+  }
+
+  for (auto dialect : dialects)
+    if (versionedDialectMap.count(dialect.name))
+      dialect.version = versionedDialectMap.lookup(dialect.name);
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Value Processing
 
 Value BytecodeReader::parseOperand(EncodingReader &reader) {
   std::vector<Value> &values = valueScopes.back().values;
   Value *value = nullptr;
   if (failed(parseEntry(reader, values, value, "value")))
     return Value();

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

void writeResourceSection(Operation *op, EncodingEmitter &emitter,
                             const BytecodeWriterConfig::Impl &config);
 
   //===--------------------------------------------------------------------===//
   // Strings
 
   void writeStringSection(EncodingEmitter &emitter);
 
   //===--------------------------------------------------------------------===//
+  // Dialect versions
+
+  void writeDialectVersionsSection(EncodingEmitter &emitter);
+
+  //===--------------------------------------------------------------------===//
   // Fields
 
   /// The builder used for the string section.
   StringSectionBuilder stringSection;
 
   /// The IR numbering state generated for the root operation.
   IRNumberingState numberingState;
 };
void BytecodeWriter::write(Operation *rootOp, raw_ostream &os,
   writeIRSection(emitter, rootOp);
 
   // Emit the resources section.
   writeResourceSection(rootOp, emitter, config);
 
   // Emit the string section.
   writeStringSection(emitter);
 
+  // Emit the dialect section.
+  writeDialectVersionsSection(emitter);
+
   // Write the generated bytecode to the provided output stream.
   emitter.writeTo(os);
 }
 
 //===----------------------------------------------------------------------===//
 // Dialects
 
 /// Write the given entries in contiguous groups with the same parent dialect.
void BytecodeWriter::writeDialectSection(EncodingEmitter &emitter) {
   auto emitOpName = [&](OpNameNumbering &name) {
     dialectEmitter.emitVarInt(stringSection.insert(name.name.stripDialect()));
   };
   writeDialectGrouping(dialectEmitter, numberingState.getOpNames(), emitOpName);
 
   emitter.emitSection(bytecode::Section::kDialect, std::move(dialectEmitter));
 }
 
+void BytecodeWriter::writeDialectVersionsSection(EncodingEmitter &emitter) {
+  EncodingEmitter dialectEmitter;
+
+  // Get dialect version.
+  auto getVersion = [&](const OpAsmDialectInterface *asmIface) -> VersionAttr {
+    // A dialect can be nullptr if not loaded. In such a case, we can't print
+    // the version properly.
+    if (asmIface)
+      return asmIface->getProducerVersion();
+    return {};
+  };
+
+  // Emit the referenced dialects.
+  auto dialects = numberingState.getDialects();
+  llvm::SmallVector<std::pair<unsigned, VersionAttr>> dialectVersionPair;
+
+  for (DialectNumbering &dialect : dialects) {
+    if (auto version = getVersion(dialect.asmInterface)) {
+      dialectVersionPair.push_back(
+          std::make_pair(stringSection.insert(dialect.name),
+                         version));
+    }
+  }
+  dialectEmitter.emitVarInt(dialectVersionPair.size());
+  for (auto item : dialectVersionPair) {
+    dialectEmitter.emitVarInt(item.first);
+    dialectEmitter.emitVarInt(item.second.size());
+    dialectEmitter.emitBytes(item.second.getRawData());
+  }
+
+  emitter.emitSection(bytecode::Section::kDialectVersions,
+                      std::move(dialectEmitter));
+}
+
 //===----------------------------------------------------------------------===//
 // Attributes and Types
 
 namespace {
 class DialectWriter : public DialectBytecodeWriter {
 public:
   DialectWriter(EncodingEmitter &emitter, IRNumberingState &numberingState,
                 StringSectionBuilder &stringSection)

mlir/lib/IR/AsmPrinter.cpp

 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/Threading.h"
 
-#include <tuple>
 #include <optional>
+#include <tuple>
 
 using namespace mlir;
 using namespace mlir::detail;
 
 #define DEBUG_TYPE "mlir-asm-printer"
 
 void OperationName::print(raw_ostream &os) const { os << getStringRef(); }
 
public:
   /// Print the given location to the stream. If `allowAlias` is true, this
   /// allows for the internal location to use an attribute alias.
   void printLocation(LocationAttr loc, bool allowAlias = false);
 
   /// Print a reference to the given resource that is owned by the given
   /// dialect.
   void printResourceHandle(const AsmDialectResourceHandle &resource);
 
+  /// Print the given version attribute as hex to the stream.
+  void printVersionAttr(VersionAttr attr);
+
   void printAffineMap(AffineMap map);
   void
   printAffineExpr(AffineExpr expr,
                   function_ref<void(unsigned, bool)> printValueName = nullptr);
   void printAffineConstraint(AffineExpr expr, bool isEq);
   void printIntegerSet(IntegerSet set);
 
 protected:

 
 void AsmPrinter::Impl::printResourceHandle(
     const AsmDialectResourceHandle &resource) {
   auto *interface = cast<OpAsmDialectInterface>(resource.getDialect());
   os << interface->getResourceKey(resource);
   state.getDialectResources()[resource.getDialect()].insert(resource);
 }
 
+void AsmPrinter::Impl::printVersionAttr(VersionAttr attr) {
+  auto rawData = attr.getRawData();
+  os << "version<";
+  printHexString(ArrayRef<char>(reinterpret_cast<const char *>(rawData.data()),
+                                rawData.size()));
+  os << ">";
+}
+
 /// Returns true if the given dialect symbol data is simple enough to print in
 /// the pretty form. This is essentially when the symbol takes the form:
 ///   identifier (`<` body `>`)?
 static bool isDialectSymbolSimpleEnoughForPrettyForm(StringRef symName) {
   // The name must start with an identifier.
   if (symName.empty() || !isalpha(symName.front()))
     return false;
 
if (!isa<BuiltinDialect>(attr.getDialect())) {
     os << ">";
     return;
   } else if (auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>()) {
     os << "dense_resource<";
     printResourceHandle(resourceAttr.getRawHandle());
     os << ">";
   } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
     printLocation(locAttr);
+  } else if (auto versionAttr = attr.dyn_cast<VersionAttr>()) {
+    printVersionAttr(versionAttr);
   } else {
     llvm::report_fatal_error("Unknown builtin attribute");
   }
   // Don't print the type if we must elide it, or if it is a None type.
   if (typeElision != AttrTypeElision::Must) {
     if (auto typedAttr = attr.dyn_cast<TypedAttr>()) {
       Type attrType = typedAttr.getType();
       if (!attrType.isa<NoneType>()) {
private:
 
   /// Print the resource sections for the file metadata dictionary.
   /// `checkAddMetadataDict` is used to indicate that metadata is going to be
   /// added, and the file metadata dictionary should be started if it hasn't
   /// yet.
   void printResourceFileMetadata(function_ref<void()> checkAddMetadataDict,
                                  Operation *op);
 
+  void printDialectVersions(Operation *op);
+
   // Contains the stack of default dialects to use when printing regions.
   // A new dialect is pushed to the stack before parsing regions nested under an
   // operation implementing `OpAsmOpInterface`, and popped when done. At the
   // top-level we start with "builtin" as the default, so that the top-level
   // `module` operation prints as-is.
   SmallVector<StringRef> defaultDialectStack{"builtin"};
 
   /// The number of spaces used for indenting nested operations.
   const static unsigned indentWidth = 2;
 
   // This is the current indentation level for nested structures.
   unsigned currentIndent = 0;
 };
 } // namespace
 
 void OperationPrinter::printTopLevelOperation(Operation *op) {
+  // Output the dialect versions directive first.
+  printDialectVersions(op);
+
   // Output the aliases at the top level that can't be deferred.
   state.getAliasState().printNonDeferredAliases(*this, newLine);
 
   // Print the module.
   printFullOpWithIndentAndLoc(op);
   os << newLine;
 
   // Output the aliases at the top level that can be deferred.
void OperationPrinter::printResourceFileMetadata(
   // resources.
   hadResource = false;
   for (const auto &printer : state.getResourcePrinters())
     processProvider("external", printer.getName(), printer);
   if (hadResource)
     os << newLine << "  }";
 }
 
+void OperationPrinter::printDialectVersions(Operation *op) {
+  // Retrieve the version to print for this dialect, if any.
+  auto getVersion = [&](Dialect *dialect) -> VersionAttr {
+    const auto interfaces = state.getDialectInterfaces();
+    const OpAsmDialectInterface *asmIface = interfaces.getInterfaceFor(dialect);
+    if (!asmIface)
+      return {};
+    return asmIface->getProducerVersion();
+  };
+
+  // If any dialect has a version to print, print the `dialect_versions`
+  // directive. This directive has to be the very first directive in the file
+  // and introduce a dictionary where the keys are dialect names and the value
+  // are attributes representing the producer version for the given dialect.
+  llvm::SmallVector<std::pair<Dialect *, VersionAttr>> dialectVersionPairs;
+  for (auto dialect : op->getContext()->getLoadedDialects()) {
+    auto version = getVersion(dialect);
+    if (version)
+      dialectVersionPairs.push_back({dialect, version});
+  }
+
+  if (dialectVersionPairs.empty())
+    return;
+
+  os << "dialect_versions { ";
+  interleaveComma(dialectVersionPairs, [&](auto item) {
+    Dialect *dialect = item.first;
+    VersionAttr attr = item.second;
+    const auto interfaces = state.getDialectInterfaces();
+    const OpAsmDialectInterface *asmIface = interfaces.getInterfaceFor(dialect);
+    auto stringOr = asmIface->printVersionAttrAsString(attr);
+    os << dialect->getNamespace() << " = ";
+    if (succeeded(stringOr)) {
+      os << "version<\"" << *stringOr << "\">";
+    } else {
+      os << attr;
+    }
+  });
+  os << " }" << newLine;
+  return;
+}
+
 /// Print a block argument in the usual format of:
 ///   %ssaName : type {attr1=42} loc("here")
 /// where location printing is controlled by the standard internal option.
 /// You may pass omitType=true to not print a type, and pass an empty
 /// attribute list if you don't care for attributes.
 void OperationPrinter::printRegionArgument(BlockArgument arg,
                                            ArrayRef<NamedAttribute> argAttrs,
                                            bool omitType) {

mlir/lib/IR/Builders.cpp

 //===----------------------------------------------------------------------===//
 // Attributes.
 //===----------------------------------------------------------------------===//
 
 NamedAttribute Builder::getNamedAttr(StringRef name, Attribute val) {
   return NamedAttribute(getStringAttr(name), val);
 }
 
+VersionAttr Builder::getVersionAttr(ArrayRef<uint8_t> data) {
+  return VersionAttr::get(context, data);
+}
+
 UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); }
 
 BoolAttr Builder::getBoolAttr(bool value) {
   return BoolAttr::get(context, value);
 }
 
 DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
   return DictionaryAttr::get(context, value);

mlir/lib/IR/BuiltinAttributes.cpp

 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/TypeSwitch.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Endian.h"
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 /// Tablegen Attribute Definitions

mlir/test/Bytecode/general.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -emit-bytecode %s | mlir-opt -allow-unregistered-dialect | FileCheck %s
 
 // Bytecode currently does not support big-endian platforms
 // UNSUPPORTED: target=s390x-{{.*}}
 
+// CHECK: dialect_versions { test = version<"1.42"> }
 // CHECK-LABEL: "bytecode.test1"
 // CHECK-NEXT:    "bytecode.empty"() : () -> ()
 // CHECK-NEXT:    "bytecode.attributes"() {attra = 10 : i64, attrb = #bytecode.attr} : () -> ()
 // CHECK-NEXT:    test.graph_region {
 // CHECK-NEXT:      "bytecode.operands"(%[[RESULTS:.*]]#0, %[[RESULTS]]#1, %[[RESULTS]]#2) : (i32, i64, i32) -> ()
 // CHECK-NEXT:      %[[RESULTS]]:3 = "bytecode.results"() : () -> (i32, i64, i32)
 // CHECK-NEXT:    }
 // CHECK-NEXT:    "bytecode.branch"()[^[[BLOCK:.*]]] : () -> ()

mlir/test/IR/ir_upgrade.mlir

+// RUN: mlir-opt -split-input-file --verify-diagnostics %s | FileCheck %s
+
+dialect_versions { test = version<"0x0100000029000000"> }
+
+// -----
+
+dialect_versions { test = version<"1.39"> }
+
+// -----
+
+// CHECK: dialect_versions { test = version<"1.42"> }
+// CHECK:  "test.versionedA"() {dims = 123 : i64} : () -> ()
+"test.versionedA"() {dims = 123 : i64} : () -> ()
+
+// -----
+
+// CHECK: dialect_versions { test = version<"1.42"> }
+// CHECK: "test.versionedA"() {dims = 123 : i64} : () -> ()
+dialect_versions { test = version<"0x0100000029000000"> }
+"test.versionedA"() {dimensions = 123 : i64} : () -> ()
+
+// -----
+
+// CHECK: dialect_versions { test = version<"1.42"> }
+// CHECK: "test.versionedA"() {dims = 123 : i64} : () -> ()
+dialect_versions { test = version<"0x0100000029000000"> }
+"test.versionedA"() {dims = 123 : i64} : () -> ()
+
+// -----
+
+// CHECK: dialect_versions { test = version<"1.42"> }
+// CHECK: test.versionedB current_version
+dialect_versions { test = version<"0x0120000009000000"> }
+test.versionedB  deprecated_syntax
+
+// -----
+
+// CHECK: dialect_versions { test = version<"1.42"> }
+// CHECK: test.versionedB current_version
+dialect_versions { test = version<"0x010000002A000000"> }
+test.versionedB  current_version
+
+// -----
+
+dialect_versions { test = version<"0x010000002A000000"> }
+// expected-error@+1{{custom op 'test.versionedB' expected 'current_version'}}
+test.versionedB  deprecated_syntax
+
+// -----
+// expected-error@-2{{current test dialect version is 1.42, can't parse version: 1.43}}
+dialect_versions { test = version<"1.43"> }
+"test.versionedA"() {dims = 123 : i64} : () -> ()
 No newline at end of file

mlir/test/lib/Dialect/Test/TestDialect.cpp

 using namespace mlir;
 using namespace test;
 
 void test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
+// TestDialect version utilities
+//===----------------------------------------------------------------------===//
+
+struct TestDialectVersion {
+  int major = 1;
+  int minor = 42;
+};
+
+// Encode/decode a version attribute
+VersionAttr encodeDialectVersion(MLIRContext *ctx,
+                                 const TestDialectVersion version) {
+  ArrayRef<uint8_t> encode(reinterpret_cast<const uint8_t *>(&version),
+                           sizeof(TestDialectVersion));
+  return Builder(ctx).getVersionAttr(encode);
+}
+
+TestDialectVersion decodeDialectVersion(const VersionAttr attribute) {
+  auto version =
+      TestDialectVersion(*reinterpret_cast<const TestDialectVersion *>(
+          attribute.getRawData().data()));
+  return version;
+}
+
+//===----------------------------------------------------------------------===//
 // TestDialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Testing the correctness of some traits.
 static_assert(
     llvm::is_detected<OpTrait::has_implicit_terminator_t,
std::optional<StringRef> aliasName =
             .Case("alias_test:dot_in_name", StringRef("test.alias"))
             .Case("alias_test:trailing_digit", StringRef("test_alias0"))
             .Case("alias_test:prefixed_digit", StringRef("0_test_alias"))
             .Case("alias_test:sanitize_conflict_a",
                   StringRef("test_alias_conflict0"))
             .Case("alias_test:sanitize_conflict_b",
                   StringRef("test_alias_conflict0_"))
             .Case("alias_test:tensor_encoding", StringRef("test_encoding"))
             .Default(std::nullopt);
     if (!aliasName)
       return AliasResult::NoAlias;
 
     os << *aliasName;
     return AliasResult::FinalAlias;
   }
 
   AliasResult getAlias(Type type, raw_ostream &os) const final {
struct TestOpAsmInterface : public OpAsmDialectInterface {
 
   FailureOr<AsmDialectResourceHandle>
   declareResource(StringRef key) const final {
     return blobManager.insert(key);
   }
 
   LogicalResult parseResource(AsmParsedResourceEntry &entry) const final {
     FailureOr<AsmResourceBlob> blob = entry.parseAsBlob();
     if (failed(blob))
       return failure();
 
     // Update the blob for this entry.
     blobManager.update(entry.getKey(), std::move(*blob));
     return success();
   }
 
   void
   buildResources(Operation *op,
                  const SetVector<AsmDialectResourceHandle> &referencedResources,
                  AsmResourceBuilder &provider) const final {
     blobManager.buildResources(provider, referencedResources.getArrayRef());
   }
 
+  // Test IR upgrade with dialect version lookup.
+  VersionAttr getProducerVersion() const final {
+    return encodeDialectVersion(getContext(), TestDialectVersion());
+  }
+
+  FailureOr<VersionAttr> parseVersionAttr(StringRef token) const final {
+    // We represent our version as a string `"major.minor"`
+    auto split = token.split('.');
+    TestDialectVersion version{.major = std::stoi(split.first.str()),
+                               .minor = std::stoi(split.second.str())};
+    return encodeDialectVersion(getContext(), version);
+  }
+
+  // We would like to represent our version as version<"major.minor">
+  FailureOr<std::string>
+  printVersionAttrAsString(VersionAttr attr) const final {
+    auto version = decodeDialectVersion(attr);
+    std::string result = std::to_string(version.major);
+    result.append(".");
+    result.append(std::to_string(version.minor));
+    return result;
+  }
+
+  LogicalResult upgradeFromVersion(Operation *topLevelOp,
+                                   VersionAttr producerVersion) const final {
+    auto version = decodeDialectVersion(producerVersion);
+    if (version.minor == 42)
+      return success();
+    if (version.minor > 42) {
+      return topLevelOp->emitError()
+             << "current test dialect version is 1.42, can't parse version: "
+             << version.major << "." << version.minor;
+    }
+    topLevelOp->walk([](TestVersionedOpA op) {
+      if (auto dims = op->getAttr("dimensions")) {
+        op->removeAttr("dimensions");
+        op->setAttr("dims", dims);
+      }
+    });
+
+    return success();
+  }
+
 private:
   /// The blob manager for the dialect.
   TestResourceBlobManagerInterface &blobManager;
 };
 
 struct TestDialectFoldInterface : public DialectFoldInterface {
   using DialectFoldInterface::DialectFoldInterface;
 
void TestOpWithRegionPattern::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<TestRemoveOpWithInnerOps>(context);
 }
 
 OpFoldResult TestOpWithRegionFold::fold(FoldAdaptor adaptor) {
   return getOperand();
 }
 
-OpFoldResult TestOpConstant::fold(FoldAdaptor adaptor) {
-  return getValue();
-}
+OpFoldResult TestOpConstant::fold(FoldAdaptor adaptor) { return getValue(); }
 
 LogicalResult TestOpWithVariadicResultsAndFolder::fold(
     FoldAdaptor adaptor, SmallVectorImpl<OpFoldResult> &results) {
   for (Value input : this->getOperands()) {
     results.push_back(input);
   }
   return success();
 }
void TestWithBoundsRegionOp::print(OpAsmPrinter &p) {
   p.printOptionalAttrDict((*this)->getAttrs());
   p << ' ';
   p.printRegionArgument(getRegion().getArgument(0), /*argAttrs=*/{},
                         /*omitType=*/true);
   p << ' ';
   p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 void TestWithBoundsRegionOp::inferResultRanges(
     ArrayRef<ConstantIntRanges> argRanges, SetIntRangeFn setResultRanges) {
   Value arg = getRegion().getArgument(0);
   setResultRanges(arg, {getUmin(), getUmax(), getSmin(), getSmax()});
 }
 
 void TestIncrementOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                         SetIntRangeFn setResultRanges) {
   const ConstantIntRanges &range = argRanges[0];
void TestReflectBoundsOp::inferResultRanges(
   Builder b(ctx);
   setUminAttr(b.getIndexAttr(range.umin().getZExtValue()));
   setUmaxAttr(b.getIndexAttr(range.umax().getZExtValue()));
   setSminAttr(b.getIndexAttr(range.smin().getSExtValue()));
   setSmaxAttr(b.getIndexAttr(range.smax().getSExtValue()));
   setResultRanges(getResult(), range);
 }
 
+//===----------------------------------------------------------------------===//
+// Test dialect_version upgrade by supporting an old syntax
+//===----------------------------------------------------------------------===//
+
+ParseResult TestVersionedOpB::parse(mlir::OpAsmParser &parser,
+                                    mlir::OperationState &state) {
+  auto versionAttr = parser.getDialectVersion("test");
+  auto version = decodeDialectVersion(versionAttr);
+  if (version.minor < 42)
+    return parser.parseKeyword("deprecated_syntax");
+  return parser.parseKeyword("current_version");
+}
+
+void TestVersionedOpB::print(OpAsmPrinter &printer) {
+  printer << " current_version";
+}
+
 #include "TestOpEnums.cpp.inc"
 #include "TestOpInterfaces.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

mlir/test/lib/Dialect/Test/TestOps.td

def TestCSEOfSingleBlockOp : TEST_Op<"cse_of_single_block_op",
   let results = (outs Variadic<AnyType>:$outputs);
   let regions = (region SizedRegion<1>:$region);
   let assemblyFormat = [{
     attr-dict `inputs` `(` $inputs `)`
     $region `:` type($inputs)  `->` type($outputs)
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// Test Ops to upgrade base on the dialect versions
+//===----------------------------------------------------------------------===//
+
+def TestVersionedOpA : TEST_Op<"versionedA"> {
+  let arguments = (ins
+   // A previous version of this dialect used the name "dimensions" for this
+   // attribute, it got renamed but we support loading old IR through
+   // upgrading, see `upgradeFromVersion()` in `TestOpAsmInterface`.
+   AnyI64Attr:$dims
+  );
+}
+
+// This op will be able to parse based on an old syntax and "auto-upgrade".
+def TestVersionedOpB : TEST_Op<"versionedB"> {
+  let arguments = (ins);
+
+  let hasCustomAssemblyFormat = 1;
+//  let parser = [{ return ::parseVersionedOp(parser, result); }];
+//  let printer = [{ return ::print(*this, p); }];
+}
+
 #endif // TEST_OPS