Add support for versioning properties in MLIR bytecode

[mfrancio]

Summary

[mlir] Add support for custom readProperties/writeProperties methods.

Currently, operations that opt-in to adopt properties will see auto-generated readProperties/writeProperties methods to emit and parse bytecode. If a dialects opts in to use usePropertiesForAttributes, those definitions will be generated for the current definition of the op without the possibility to handle attribute versioning.

The patch adds the capability for an operation to define its own read/write methods for the encoding of properties so that versioned operations can handle upgrading properties encodings.

In addition to this, the patch adds an example showing versioning on NamedProperties through the dialect version API exposed by the reader.

[mehdi_amini]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1072 ↗

(On Diff #540569)

I am not fond of having this weird transactional way of changing the state of the reader temporarily to carry this information.

Here is a patch

map.patch7 KBDownload

that add a map that would allow clients to get a version for any dialect by name: can we use this kind of mechanism instead?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1545

I think we should split the logic for adding bytecode in another method and keep the control flow simple.

Can you outline the code from line 1337 to the end?

(I think this method has outgrown what's reasonable anyway)

[mfrancio]

• Refactors the way the dialect version is exposed to the reader
• Outlines readProperties/writeProperties methods generation into a new method of OpEmitter

[mfrancio]

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

1072 ↗

(On Diff #540569)

Makes sense to do this - i leveraged it to refactor the dialect reader, which now holds a reference of the map since construction.

BTW, does it make sense anymore now to have readAttribute/readType taking a version?
https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Bytecode/BytecodeImplementation.h#L301

I feel we should consolidate the two methods.

I will also use the same strategy for https://reviews.llvm.org/D153383, which simplifies things a bit.

[jpienaar]

BTW, does it make sense anymore now to have readAttribute/readType taking a version?

https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Bytecode/BytecodeImplementation.h#L301

Not if already accessible on reader no.

I'm not sure what consolidating would mean though, I think we need a separate read for attribute and type given they only differ in return (c++) type

[mfrancio]

In D155340#4508225, @jpienaar wrote:

BTW, does it make sense anymore now to have readAttribute/readType taking a version?

https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Bytecode/BytecodeImplementation.h#L301

Not if already accessible on reader no.

I'm not sure what consolidating would mean though, I think we need a separate read for attribute and type given they only differ in return (c++) type

Exactly, once the reader have access to the version there is no need of having a specific API with a version passed as an argument.

[mfrancio]

Rebase

[mfrancio]

Edit commit message

mlir/include/mlir/IR/OpBase.td

class Op<Dialect dialect, string mnemonic, list<Trait> props = []> {
 
   // Whether this op has a static "canonicalize" method to perform "match and
   // rewrite patterns".
   bit hasCanonicalizeMethod = 0;
 
   // Whether this op has a folder.
   bit hasFolder = 0;
 
+  // Whether to let ops implement their custom `readProperties` and
+  // `writeProperties` methods to emit bytecode.
+  bit useCustomPropertiesEncoding = 0;
+
   // Op traits.
   // Note: The list of traits will be uniqued by ODS.
   list<Trait> traits = props;
 
   // Additional code that will be added to the public part of the generated
   // C++ code of the op declaration.
   code extraClassDeclaration = ?;
 

mlir/include/mlir/TableGen/Operator.h

public:
   /// Returns the setter name for the accessor of `name`.
   std::string getSetterName(StringRef name) const;
 
   /// Returns the remove name for the accessor of `name`.
   std::string getRemoverName(StringRef name) const;
 
   bool hasFolder() const;
 
+  /// Whether to generate the `readProperty`/`writeProperty` methods for
+  /// bytecode emission.
+  bool useCustomPropertiesEncoding() const;
+
 private:
   /// Populates the vectors containing operands, attributes, results and traits.
   void populateOpStructure();
 
   /// Populates type inference info (mostly equality) with input a mapping from
   /// names to indices for arguments and results.
   void populateTypeInferenceInfo(
       const llvm::StringMap<int> &argumentsAndResultsIndex);

mlir/lib/TableGen/Operator.cpp

std::string Operator::getSetterName(StringRef name) const {
   return "set" + convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
 }
 
 std::string Operator::getRemoverName(StringRef name) const {
   return "remove" + convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
 }
 
 bool Operator::hasFolder() const { return def.getValueAsBit("hasFolder"); }
+
+bool Operator::useCustomPropertiesEncoding() const {
+  return def.getValueAsBit("useCustomPropertiesEncoding");
+}

mlir/test/Bytecode/versioning/versioned_bytecode.mlir

 // This file contains test cases related to roundtripping.
 
 //===--------------------------------------------------------------------===//
 // Test roundtrip
 //===--------------------------------------------------------------------===//
 
-// RUN: mlir-opt %S/versioned-op-1.12.mlirbc -emit-bytecode \
+// RUN: mlir-opt %S/versioned-op-with-prop-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: mlir-opt %S/versioned-op-with-prop-1.12.mlirbc -o %t.2 && \
 // RUN: diff %t.1 %t.2
 
 //===--------------------------------------------------------------------===//
 // Test invalid versions
 //===--------------------------------------------------------------------===//
 
-// RUN: not mlir-opt %S/versioned-op-1.12.mlirbc -emit-bytecode \
+// RUN: not mlir-opt %S/versioned-op-with-prop-1.12.mlirbc -emit-bytecode \
 // RUN:   -emit-bytecode-version=-1 2>&1 | FileCheck %s --check-prefix=ERR_VERSION_NEGATIVE
 // ERR_VERSION_NEGATIVE: unsupported version requested -1, must be in range [{{[0-9]+}}, {{[0-9]+}}]
 
-// RUN: not mlir-opt %S/versioned-op-1.12.mlirbc -emit-bytecode \
+// RUN: not mlir-opt %S/versioned-op-with-prop-1.12.mlirbc -emit-bytecode \
 // RUN:   -emit-bytecode-version=999 2>&1 | FileCheck %s --check-prefix=ERR_VERSION_FUTURE
 // ERR_VERSION_FUTURE: unsupported version requested 999, must be in range [{{[0-9]+}}, {{[0-9]+}}]

mlir/test/Bytecode/versioning/versioned_op.mlir

 // This file contains test cases related to the dialect post-parsing upgrade
 // mechanism.
 
 //===--------------------------------------------------------------------===//
 // Test generic
 //===--------------------------------------------------------------------===//
 
 // COM: bytecode contains
 // COM: module {
 // COM:   version: 2.0
 // COM:   "test.versionedA"() <{dims = 123 : i64, modifier = false}> : () -> ()
 // COM: }
-// RUN: mlir-opt %S/versioned-op-2.0.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: mlir-opt %S/versioned-op-with-prop-2.0.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK1
 // CHECK1: "test.versionedA"() <{dims = 123 : i64, modifier = false}> : () -> ()
 
 //===--------------------------------------------------------------------===//
 // Test upgrade
 //===--------------------------------------------------------------------===//
 
 // COM: bytecode contains
 // COM: module {
 // COM:   version: 1.12
 // COM:   "test.versionedA"() <{dimensions = 123 : i64}> : () -> ()
 // COM: }
-// RUN: mlir-opt %S/versioned-op-1.12.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK2
-// CHECK2: "test.versionedA"() <{dims = 123 : i64, modifier = false}> : () -> ()
+// RUN: mlir-opt %S/versioned-op-with-prop-1.12.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK3
+// CHECK3: "test.versionedA"() <{dims = 123 : i64, modifier = false}> : () -> ()
 
 //===--------------------------------------------------------------------===//
 // Test forbidden downgrade
 //===--------------------------------------------------------------------===//
 
 // COM: bytecode contains
 // COM: module {
 // COM:   version: 2.2
 // COM:   "test.versionedA"() <{dims = 123 : i64, modifier = false}> : () -> ()
 // COM: }
 // RUN: not mlir-opt %S/versioned-op-2.2.mlirbc 2>&1 | FileCheck %s --check-prefix=ERR_NEW_VERSION
 // ERR_NEW_VERSION: current test dialect version is 2.0, can't parse version: 2.2

mlir/test/Bytecode/versioning/versioned_op_with_native_properties.mlir

+// This file contains test cases related to the dialect post-parsing upgrade
+// mechanism.
+// COM: those tests parse bytecode that was generated before test dialect
+//      adopted `usePropertiesFromAttributes`.
+
+//===--------------------------------------------------------------------===//
+// Test generic
+//===--------------------------------------------------------------------===//
+
+// COM: bytecode contains
+// COM: module {
+// COM:   version: 2.0
+// COM:   test.with_versioned_properties 1 | 2
+// COM: }
+// RUN: mlir-opt %S/versioned-op-with-native-prop-2.0.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK1
+// CHECK1: test.with_versioned_properties 1 | 2
+
+//===--------------------------------------------------------------------===//
+// Test upgrade
+//===--------------------------------------------------------------------===//
+
+// COM: bytecode contains
+// COM: module {
+// COM:   version: 1.12
+
+// COM: }
+// RUN: mlir-opt %S/versioned-op-with-native-prop-1.12.mlirbc 2>&1 | FileCheck %s --check-prefix=CHECK3
+// CHECK3: test.with_versioned_properties 1 | 0

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

public:
   static mlir::LogicalResult setFromAttr(MyPropStruct &prop,
                                          mlir::Attribute attr,
                                          mlir::InFlightDiagnostic *diag);
   llvm::hash_code hash() const;
   bool operator==(const MyPropStruct &rhs) const {
     return content == rhs.content;
   }
 };
+struct VersionedProperties {
+  // For the sake of testing, assume that this object was associated to version
+  // 1.2 of the test dialect when having only one int value. In the current
+  // version 2.0, the property has two values. We also assume that the class is
+  // upgrade-able if value2 = 0.
+  int value1;
+  int value2;
+  bool operator==(const VersionedProperties &rhs) const {
+    return value1 == rhs.value1 && value2 == rhs.value2;
+  }
+};
 } // namespace test
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 namespace test {
 
 // Op deliberately defined in C++ code rather than ODS to test that C++

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

 static DictionaryAttr
 getPropertiesAsAttribute(MLIRContext *ctx,
                          const PropertiesWithCustomPrint &prop);
 static llvm::hash_code computeHash(const PropertiesWithCustomPrint &prop);
 static void customPrintProperties(OpAsmPrinter &p,
                                   const PropertiesWithCustomPrint &prop);
 static ParseResult customParseProperties(OpAsmParser &parser,
                                          PropertiesWithCustomPrint &prop);
+static LogicalResult setPropertiesFromAttribute(VersionedProperties &prop,
+                                                Attribute attr,
+                                                InFlightDiagnostic *diagnostic);
+static DictionaryAttr getPropertiesAsAttribute(MLIRContext *ctx,
+                                               const VersionedProperties &prop);
+static llvm::hash_code computeHash(const VersionedProperties &prop);
+static void customPrintProperties(OpAsmPrinter &p,
+                                  const VersionedProperties &prop);
+static ParseResult customParseProperties(OpAsmParser &parser,
+                                         VersionedProperties &prop);
 
 void test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
 // Dynamic operations
 //===----------------------------------------------------------------------===//
static ParseResult customParseProperties(OpAsmParser &parser,
                                          PropertiesWithCustomPrint &prop) {
   std::string label;
   if (parser.parseKeywordOrString(&label) || parser.parseKeyword("is") ||
       parser.parseInteger(prop.value))
     return failure();
   prop.label = std::make_shared<std::string>(std::move(label));
   return success();
 }
+static LogicalResult
+setPropertiesFromAttribute(VersionedProperties &prop, Attribute attr,
+                           InFlightDiagnostic *diagnostic) {
+  DictionaryAttr dict = dyn_cast<DictionaryAttr>(attr);
+  if (!dict) {
+    if (diagnostic)
+      *diagnostic << "expected DictionaryAttr to set VersionedProperties";
+    return failure();
+  }
+  auto value1Attr = dict.getAs<IntegerAttr>("value1");
+  if (!value1Attr) {
+    if (diagnostic)
+      *diagnostic << "expected IntegerAttr for key `value1`";
+    return failure();
+  }
+  auto value2Attr = dict.getAs<IntegerAttr>("value2");
+  if (!value2Attr) {
+    if (diagnostic)
+      *diagnostic << "expected IntegerAttr for key `value2`";
+    return failure();
+  }
+
+  prop.value1 = value1Attr.getValue().getSExtValue();
+  prop.value2 = value2Attr.getValue().getSExtValue();
+  return success();
+}
+static DictionaryAttr
+getPropertiesAsAttribute(MLIRContext *ctx, const VersionedProperties &prop) {
+  SmallVector<NamedAttribute> attrs;
+  Builder b{ctx};
+  attrs.push_back(b.getNamedAttr("value1", b.getI32IntegerAttr(prop.value1)));
+  attrs.push_back(b.getNamedAttr("value2", b.getI32IntegerAttr(prop.value2)));
+  return b.getDictionaryAttr(attrs);
+}
+static llvm::hash_code computeHash(const VersionedProperties &prop) {
+  return llvm::hash_combine(prop.value1, prop.value2);
+}
+static void customPrintProperties(OpAsmPrinter &p,
+                                  const VersionedProperties &prop) {
+  p << prop.value1 << " | " << prop.value2;
+}
+static ParseResult customParseProperties(OpAsmParser &parser,
+                                         VersionedProperties &prop) {
+  if (parser.parseInteger(prop.value1) || parser.parseVerticalBar() ||
+      parser.parseInteger(prop.value2))
+    return failure();
+  return success();
+}
 
 static bool parseUsingPropertyInCustom(OpAsmParser &parser, int64_t value[3]) {
   return parser.parseLSquare() || parser.parseInteger(value[0]) ||
          parser.parseComma() || parser.parseInteger(value[1]) ||
          parser.parseComma() || parser.parseInteger(value[2]) ||
          parser.parseRSquare();
 }
 
void TestStoreWithARegion::getSuccessorRegions(
   }
 }
 
 MutableOperandRange TestStoreWithARegionTerminator::getMutableSuccessorOperands(
     std::optional<unsigned> index) {
   return MutableOperandRange(getOperation());
 }
 
+LogicalResult
+TestVersionedOpA::readProperties(::mlir::DialectBytecodeReader &reader,
+                                 ::mlir::OperationState &state) {
+  auto &prop = state.getOrAddProperties<Properties>();
+  if (::mlir::failed(reader.readAttribute(prop.dims)))
+    return ::mlir::failure();
+
+  // Check if we have a version. If not, assume we are parsing the current
+  // version.
+  auto maybeVersion = reader.getDialectVersion("test");
+  if (succeeded(maybeVersion)) {
+    // If version is less than 2.0, there is no additional attribute to parse.
+    // We can materialize missing properties post parsing before verification.
+    const auto *version =
+        reinterpret_cast<const TestDialectVersion *>(*maybeVersion);
+    if ((version->major < 2)) {
+      return success();
+    }
+  }
+
+  if (::mlir::failed(reader.readAttribute(prop.modifier)))
+    return ::mlir::failure();
+  return ::mlir::success();
+}
+
+void TestVersionedOpA::writeProperties(::mlir::DialectBytecodeWriter &writer) {
+  auto &prop = getProperties();
+  writer.writeAttribute(prop.dims);
+  writer.writeAttribute(prop.modifier);
+}
+
+::mlir::LogicalResult TestOpWithVersionedProperties::readFromMlirBytecode(
+    ::mlir::DialectBytecodeReader &reader, test::VersionedProperties &prop) {
+  uint64_t value1, value2 = 0;
+  if (failed(reader.readVarInt(value1)))
+    return failure();
+
+  // Check if we have a version. If not, assume we are parsing the current
+  // version.
+  auto maybeVersion = reader.getDialectVersion("test");
+  bool needToParseAnotherInt = true;
+  if (succeeded(maybeVersion)) {
+    // If version is less than 2.0, there is no additional attribute to parse.
+    // We can materialize missing properties post parsing before verification.
+    const auto *version =
+        reinterpret_cast<const TestDialectVersion *>(*maybeVersion);
+    if ((version->major < 2))
+      needToParseAnotherInt = false;
+  }
+  if (needToParseAnotherInt && failed(reader.readVarInt(value2)))
+    return failure();
+
+  prop.value1 = value1;
+  prop.value2 = value2;
+  return success();
+}
+void TestOpWithVersionedProperties::writeToMlirBytecode(
+    ::mlir::DialectBytecodeWriter &writer,
+    const test::VersionedProperties &prop) {
+  writer.writeVarInt(prop.value1);
+  writer.writeVarInt(prop.value2);
+}
+
 #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/TestDialectInterfaces.cpp

LogicalResult upgradeFromVersion(Operation *topLevelOp,
     if (version.major > 2 || (version.major == 2 && version.minor > 0)) {
       return topLevelOp->emitError()
              << "current test dialect version is 2.0, can't parse version: "
              << version.major << "." << version.minor;
     }
     // Prior version 2.0, the old op supported only a single attribute called
     // "dimensions". We can perform the upgrade.
     topLevelOp->walk([](TestVersionedOpA op) {
-      if (auto dims = op->getAttr("dimensions")) {
-        op->removeAttr("dimensions");
-        op->setAttr("dims", dims);
-      }
-      op->setAttr("modifier", BoolAttr::get(op->getContext(), false));
+      // Prior version 2.0, `readProperties` did not process the modifier
+      // attribute. Handle that according to the version here.
+      auto &prop = op.getProperties();
+      prop.modifier = BoolAttr::get(op->getContext(), false);
     });
     return success();
   }
 
 private:
   Attribute readAttrNewEncoding(DialectBytecodeReader &reader) const {
     uint64_t encoding;
     if (failed(reader.readVarInt(encoding)) ||

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

 }
 
 def OpWithShapedTypeInferTypeInterfaceOp : TEST_Op<"op_with_shaped_type_infer_type_if",
       [InferTensorTypeWithReify]> {
   let arguments = (ins AnyTensor, AnyTensor);
   let results = (outs AnyTensor);
 }
 
-def OpWithShapedTypeInferTypeAdaptorInterfaceOp : 
+def OpWithShapedTypeInferTypeAdaptorInterfaceOp :
       TEST_Op<"op_with_shaped_type_infer_type_adaptor_if",
               [InferTensorTypeAdaptorWithReify]> {
   let arguments = (ins AnyTensor:$operand1, AnyTensor:$operand2);
   let results = (outs AnyTensor:$result);
 }
 
 def OpWithResultShapeInterfaceOp : TEST_Op<"op_with_result_shape_interface",
       [DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
def TestVersionedOpA : TEST_Op<"versionedA"> {
   // In the current version (2.0) "dimensions" was renamed to "dims", and a new
   // boolean attribute "modifier" was added. The previous version of the op
   // corresponds to "modifier=false". We support loading old IR through
   // upgrading, see `upgradeFromVersion()` in `TestBytecodeDialectInterface`.
   let arguments = (ins
    AnyI64Attr:$dims,
    BoolAttr:$modifier
   );
+
+  // Since we use properties to store attributes, we need a custom encoding
+  // reader/writer to handle versioning.
+  let useCustomPropertiesEncoding = 1;
 }
 
 def TestVersionedOpB : TEST_Op<"versionedB"> {
   // A previous version of the dialect (let's say 1.*) we encoded TestAttrParams
   // with a custom encoding:
   //
   //    #test.attr_params<X, Y> -> { varInt: Y, varInt: X }
   //
::mlir::ParseResult TestOpWithNiceProperties::parseProperties(
       Properties &prop = result.getOrAddProperties<Properties>();
       if (customParseProperties(parser, prop.prop))
         return failure();
       return success();
     }
   }];
 }
 
+def VersionedProperties : Property<"VersionedProperties"> {
+  let convertToAttribute = [{
+      getPropertiesAsAttribute($_ctxt, $_storage)
+  }];
+  let convertFromAttribute = [{
+    return setPropertiesFromAttribute($_storage, $_attr, $_diag);
+  }];
+  let hashProperty = [{
+    computeHash($_storage);
+  }];
+}
+
+def TestOpWithVersionedProperties : TEST_Op<"with_versioned_properties"> {
+  let assemblyFormat = "prop-dict attr-dict";
+  let arguments = (ins
+     VersionedProperties:$prop
+  );
+  let extraClassDeclaration = [{
+    void printProperties(::mlir::MLIRContext *ctx, ::mlir::OpAsmPrinter &p,
+                         const Properties &prop);
+    static ::mlir::ParseResult  parseProperties(::mlir::OpAsmParser &parser,
+                                     ::mlir::OperationState &result);
+    static ::mlir::LogicalResult readFromMlirBytecode(
+        ::mlir::DialectBytecodeReader &,
+        test::VersionedProperties &prop);
+    static void writeToMlirBytecode(
+        ::mlir::DialectBytecodeWriter &,
+        const test::VersionedProperties &prop);
+  }];
+  let extraClassDefinition = [{
+    void TestOpWithVersionedProperties::printProperties(::mlir::MLIRContext *ctx,
+            ::mlir::OpAsmPrinter &p, const Properties &prop) {
+      customPrintProperties(p, prop.prop);
+    }
+    ::mlir::ParseResult TestOpWithVersionedProperties::parseProperties(
+        ::mlir::OpAsmParser &parser,
+        ::mlir::OperationState &result) {
+      Properties &prop = result.getOrAddProperties<Properties>();
+      if (customParseProperties(parser, prop.prop))
+        return failure();
+      return success();
+    }
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Test Dataflow
 //===----------------------------------------------------------------------===//
 
 def TestCallAndStoreOp : TEST_Op<"call_and_store",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   let arguments = (ins
     SymbolRefAttr:$callee,
     Arg<AnyMemRef, "", [MemWrite]>:$address,
     Variadic<AnyType>:$callee_operands,
     BoolAttr:$store_before_call
   );
   let results = (outs
     Variadic<AnyType>:$results
   );
   let assemblyFormat =
     "$callee `(` $callee_operands `)` `,` $address attr-dict "
     "`:` functional-type(operands, results)";
 }
 
 def TestStoreWithARegion : TEST_Op<"store_with_a_region",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
      SingleBlock]> {
-  let arguments = (ins 
+  let arguments = (ins
     Arg<AnyMemRef, "", [MemWrite]>:$address,
     BoolAttr:$store_before_region
   );
   let regions = (region AnyRegion:$body);
   let assemblyFormat =
     "$address attr-dict-with-keyword regions `:` type($address)";
 }
 
 def TestStoreWithARegionTerminator : TEST_Op<"store_with_a_region_terminator",
     [DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>, Terminator, NoMemoryEffect]> {
   let assemblyFormat = "attr-dict";
 }
 
 #endif // TEST_OPS

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 //===----------------------------------------------------------------------===//
 // Op emitter
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Helper class to emit a record into the given output stream.
 class OpEmitter {
+  using ConstArgument =
+      llvm::PointerUnion<const AttributeMetadata *, const NamedProperty *>;
+
 public:
   static void
   emitDecl(const Operator &op, raw_ostream &os,
            const StaticVerifierFunctionEmitter &staticVerifierEmitter);
   static void
   emitDef(const Operator &op, raw_ostream &os,
           const StaticVerifierFunctionEmitter &staticVerifierEmitter);
 
private:
   void genOpAsmInterface();
 
   // Generates the `getOperationName` method for this op.
   void genOpNameGetter();
 
   // Generates code to manage the properties, if any!
   void genPropertiesSupport();
 
+  // Generates code to manage the encoding of properties to bytecode.
+  void
+  genPropertiesSupportForBytecode(ArrayRef<ConstArgument> attrOrProperties);
+
   // Generates getters for the attributes.
   void genAttrGetters();
 
   // Generates setter for the attributes.
   void genAttrSetters();
 
   // Generates removers for optional attributes.
   void genOptionalAttrRemovers();
static void emitAttrGetterWithReturnType(FmtContext &fctx,
   body << "  return "
        << tgfmt(attr.getConvertFromStorageCall(), &fctx.withSelf("attr"))
        << ";\n";
 }
 
 void OpEmitter::genPropertiesSupport() {
   if (!emitHelper.hasProperties())
     return;
-  using ConstArgument =
-      llvm::PointerUnion<const AttributeMetadata *, const NamedProperty *>;
 
   SmallVector<ConstArgument> attrOrProperties;
   for (const std::pair<StringRef, AttributeMetadata> &it :
        emitHelper.getAttrMetadata()) {
     if (!it.second.constraint || !it.second.constraint->isDerivedAttr())
       attrOrProperties.push_back(&it.second);
   }
   for (const NamedProperty &prop : op.getProperties())
auto &verifyInherentAttrsMethod =
               "::mlir::LogicalResult", "verifyInherentAttrs",
               MethodParameter("::mlir::OperationName", "opName"),
               MethodParameter("::mlir::NamedAttrList &", "attrs"),
               MethodParameter(
                   "llvm::function_ref<::mlir::InFlightDiagnostic()>",
                   "getDiag"))
           ->body();
 
-  auto &readPropertiesMethod =
-      opClass
-          .addStaticMethod(
-              "::mlir::LogicalResult", "readProperties",
-              MethodParameter("::mlir::DialectBytecodeReader &", "reader"),
-              MethodParameter("::mlir::OperationState &", "state"))
-          ->body();
-
-  auto &writePropertiesMethod =
-      opClass
-          .addMethod(
-              "void", "writeProperties",
-              MethodParameter("::mlir::DialectBytecodeWriter &", "writer"))
-          ->body();
-
   opClass.declare<UsingDeclaration>("Properties", "FoldAdaptor::Properties");
 
   // Convert the property to the attribute form.
 
   setPropMethod << R"decl(
   ::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
   if (!dict) {
     if (diag)
if (canEmitAttrVerifier(attr,
         return ::mlir::failure();
     }
 )",
                      name, constraintFn, namedAttr->attrName);
     }
   }
   verifyInherentAttrsMethod << "    return ::mlir::success();";
 
+  // Generate methods to interact with bytecode.
+  genPropertiesSupportForBytecode(attrOrProperties);
+}
+
+void OpEmitter::genPropertiesSupportForBytecode(
+    ArrayRef<ConstArgument> attrOrProperties) {
+  if (op.useCustomPropertiesEncoding()) {
+    opClass.declareStaticMethod(
+        "::mlir::LogicalResult", "readProperties",
+        MethodParameter("::mlir::DialectBytecodeReader &", "reader"),
+        MethodParameter("::mlir::OperationState &", "state"));
+    opClass.declareMethod(
+        "void", "writeProperties",
+        MethodParameter("::mlir::DialectBytecodeWriter &", "writer"));
+    return;
+  }
+
+  auto &readPropertiesMethod =
+      opClass
+          .addStaticMethod(
+              "::mlir::LogicalResult", "readProperties",
+              MethodParameter("::mlir::DialectBytecodeReader &", "reader"),
+              MethodParameter("::mlir::OperationState &", "state"))
+          ->body();
+
+  auto &writePropertiesMethod =
+      opClass
+          .addMethod(
+              "void", "writeProperties",
+              MethodParameter("::mlir::DialectBytecodeWriter &", "writer"))
+          ->body();
+
   // Populate bytecode serialization logic.
   readPropertiesMethod
       << "  auto &prop = state.getOrAddProperties<Properties>(); (void)prop;";
   writePropertiesMethod << "  auto &prop = getProperties(); (void)prop;\n";
   for (const auto &attrOrProp : attrOrProperties) {
     if (const auto *namedProperty =
             attrOrProp.dyn_cast<const NamedProperty *>()) {
       StringRef name = namedProperty->name;