example w/ unknown attributes

Author: nikalra

mlir/test/Bytecode/versioning/versioning-fallback.mlir

@@ -1,10 +1,23 @@
 // RUN: mlir-opt %s --emit-bytecode > %T/versioning-fallback.mlirbc
-"test.versionedD"() <{attribute = #test.attr_params<42, 24>}> : () -> ()
+"test.versionedD"() <{
+  attribute = #test.compound_attr_no_reading<
+    noReadingNested = #test.compound_attr_no_reading_nested<
+      value = "foo", 
+      payload = [24, "bar"]
+    >, 
+    supportsReading = #test.attr_params<42, 24>
+  >
+}> : () -> ()
 
 // COM: check that versionedD was parsed as a fallback op.
 // RUN: mlir-opt %T/versioning-fallback.mlirbc | FileCheck %s --check-prefix=CHECK-PARSE
 // CHECK-PARSE: test.bytecode.fallback 
-// CHECK-PARSE-SAME: opname = "test.versionedD"
+// CHECK-PARSE-SAME: encodedReqdAttributes = [#test.bytecode_fallback<attrIndex = 100, 
+// CHECK-PARSE-SAME:  encodedReqdAttributes = [#test.bytecode_fallback<attrIndex = 101, 
+// CHECK-PARSE-SAME:    encodedReqdAttributes = ["foo", [24, "bar"]], 
+// CHECK-PARSE-SAME:  #test.attr_params<42, 24>
+// CHECK-PARSE-SAME: opname = "test.versionedD", 
+// CHECK-PARSE-SAME: opversion = 1
 
 // COM: check that the bytecode roundtrip was successful
 // RUN: mlir-opt %T/versioning-fallback.mlirbc --verify-roundtrip

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

@@ -405,4 +405,41 @@ def TestOpAsmAttrInterfaceAttr : Test_Attr<"TestOpAsmAttrInterface",
   }];
 }
 
+// Test fallback attributes.
+def TestBytecodeFallbackAttr : Test_Attr<"TestBytecodeFallback"> {
+  let mnemonic = "bytecode_fallback";
+  let parameters = (ins 
+    "uint64_t":$attrIndex,
+    "::mlir::ArrayAttr":$encodedReqdAttributes,
+    "::mlir::ArrayAttr":$encodedOptAttributes);
+
+  let assemblyFormat = [{
+    `<` struct(params) `>`
+  }];
+}
+
+// New nested CompoundAttr to validate bytecode fallback attr.
+def CompoundAttrNoReadingNested : Test_Attr<"CompoundAttrNoReadingNested"> {
+  let mnemonic = "compound_attr_no_reading_nested";
+  let parameters = (ins
+    "::mlir::StringAttr":$value,
+    "::mlir::ArrayAttr":$payload);
+
+  let assemblyFormat = [{
+    `<` struct(params) `>`
+  }];
+}
+
+// New CompoundAttr to validate bytecode fallback attr.
+def CompoundAttrNoReading : Test_Attr<"CompoundAttrNoReading"> {
+  let mnemonic = "compound_attr_no_reading";
+  let parameters = (ins
+    CompoundAttrNoReadingNested:$noReadingNested,
+    TestAttrParams:$supportsReading);
+  
+  let assemblyFormat = [{
+    `<` struct(params) `>`
+  }];
+}
+
 #endif // TEST_ATTRDEFS

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

@@ -8,10 +8,14 @@
 
 #include "TestDialect.h"
 #include "TestOps.h"
+#include "mlir/Bytecode/BytecodeImplementation.h"
+#include "mlir/IR/Attributes.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/Interfaces/FoldInterfaces.h"
 #include "mlir/Reducer/ReductionPatternInterface.h"
 #include "mlir/Transforms/InliningUtils.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/LogicalResult.h"
 
 using namespace mlir;
 using namespace test;
@@ -40,7 +44,12 @@ struct TestResourceBlobManagerInterface
 };
 
 namespace {
-enum test_encoding { k_attr_params = 0, k_test_i32 = 99 };
+enum test_encoding {
+  k_attr_params = 0,
+  k_test_i32 = 99,
+  kCompoundAttrNoReading = 100,
+  kCompoundAttrNoReadingNested = 101
+};
 } // namespace
 
 // Test support for interacting with the Bytecode reader/writer.
@@ -67,6 +76,39 @@ struct TestBytecodeDialectInterface : public BytecodeDialectInterface {
     return Type();
   }
 
+  struct FallbackCompliantAttributeEncoding {
+    SmallVector<Attribute> requiredAttributes;
+    SmallVector<Attribute> optionalAttributes;
+
+    LogicalResult write(DialectBytecodeWriter &writer, uint64_t attributeCode) {
+      writer.writeVarInt(attributeCode);
+      writer.writeList(requiredAttributes,
+                       [&](Attribute attr) { writer.writeAttribute(attr); });
+      writer.writeList(optionalAttributes, [&](Attribute attr) {
+        writer.writeOptionalAttribute(attr);
+      });
+      return success();
+    }
+
+    LogicalResult read(DialectBytecodeReader &reader) {
+      // The attribute code should be pre-populated.
+
+      // Read the required attributes.
+      if (failed(reader.readList(requiredAttributes, [&](Attribute &attr) {
+            return reader.readAttribute(attr);
+          })))
+        return failure();
+
+      // Read the optional attributes.
+      if (failed(reader.readList(optionalAttributes, [&](Attribute &attr) {
+            return reader.readOptionalAttribute(attr);
+          })))
+        return failure();
+
+      return success();
+    }
+  };
+
   LogicalResult writeAttribute(Attribute attr,
                                DialectBytecodeWriter &writer) const final {
     if (auto concreteAttr = llvm::dyn_cast<TestAttrParamsAttr>(attr)) {
@@ -75,6 +117,32 @@ struct TestBytecodeDialectInterface : public BytecodeDialectInterface {
       writer.writeVarInt(concreteAttr.getV1());
       return success();
     }
+
+    if (auto concreteAttr = dyn_cast<CompoundAttrNoReadingAttr>(attr)) {
+      FallbackCompliantAttributeEncoding encoding = {
+          .requiredAttributes = {concreteAttr.getNoReadingNested(),
+                                 concreteAttr.getSupportsReading()},
+          .optionalAttributes = {}};
+      return encoding.write(writer, kCompoundAttrNoReading);
+    }
+
+    if (auto concreteAttr = dyn_cast<CompoundAttrNoReadingNestedAttr>(attr)) {
+      FallbackCompliantAttributeEncoding encoding = {
+          .requiredAttributes = {concreteAttr.getValue(),
+                                 concreteAttr.getPayload()},
+          .optionalAttributes = {}};
+      return encoding.write(writer, kCompoundAttrNoReadingNested);
+    }
+
+    if (auto concreteAttr = dyn_cast<TestBytecodeFallbackAttr>(attr)) {
+      FallbackCompliantAttributeEncoding encoding = {
+          .requiredAttributes =
+              llvm::to_vector(concreteAttr.getEncodedReqdAttributes()),
+          .optionalAttributes =
+              llvm::to_vector(concreteAttr.getEncodedOptAttributes())};
+      return encoding.write(writer, concreteAttr.getAttrIndex());
+    }
+
     return failure();
   }
 
@@ -146,16 +214,29 @@ struct TestBytecodeDialectInterface : public BytecodeDialectInterface {
 
 private:
   Attribute readAttrNewEncoding(DialectBytecodeReader &reader) const {
-    uint64_t encoding;
-    if (failed(reader.readVarInt(encoding)) ||
-        encoding != test_encoding::k_attr_params)
+    uint64_t attributeCode;
+    if (failed(reader.readVarInt(attributeCode)))
       return Attribute();
-    // The new encoding has v0 first, v1 second.
-    uint64_t v0, v1;
-    if (failed(reader.readVarInt(v0)) || failed(reader.readVarInt(v1)))
-      return Attribute();
-    return TestAttrParamsAttr::get(getContext(), static_cast<int>(v0),
-                                   static_cast<int>(v1));
+
+    switch (attributeCode) {
+    case test_encoding::k_attr_params: {
+      // The new encoding has v0 first, v1 second.
+      uint64_t v0, v1;
+      if (failed(reader.readVarInt(v0)) || failed(reader.readVarInt(v1)))
+        return Attribute();
+      return TestAttrParamsAttr::get(getContext(), static_cast<int>(v0),
+                                     static_cast<int>(v1));
+    }
+    default: {
+      FallbackCompliantAttributeEncoding encoding;
+      if (failed(encoding.read(reader)))
+        return {};
+      return TestBytecodeFallbackAttr::get(
+          reader.getContext(), attributeCode,
+          ArrayAttr::get(reader.getContext(), encoding.requiredAttributes),
+          ArrayAttr::get(reader.getContext(), encoding.optionalAttributes));
+    }
+    }
   }
 
   Attribute readAttrOldEncoding(DialectBytecodeReader &reader) const {

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

@@ -3032,7 +3032,7 @@ def TestVersionedOpC : TEST_Op<"versionedC"> {
 
 // This op is used to generate tests for the bytecode dialect fallback path.
 def TestVersionedOpD : TEST_Op<"versionedD"> {
-  let arguments = (ins AnyAttrOf<[TestAttrParams,
+  let arguments = (ins AnyAttrOf<[CompoundAttrNoReading,
                                   I32ElementsAttr]>:$attribute
   );