first shim

Author: nikalra

mlir/include/mlir/Bytecode/BytecodeImplementation.h

@@ -21,6 +21,7 @@
 #include "mlir/IR/OpImplementation.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace mlir {
 //===--------------------------------------------------------------------===//
@@ -445,6 +446,14 @@ class BytecodeDialectInterface
     return Type();
   }
 
+  /// Fall back to an operation of this type if parsing an op from bytecode
+  /// fails for any reason. This can be used to handle new ops emitted from a
+  /// different version of the dialect, that cannot be read by an older version
+  /// of the dialect.
+  virtual FailureOr<OperationName> getFallbackOperationName() const {
+    return failure();
+  }
+
   //===--------------------------------------------------------------------===//
   // Writing
   //===--------------------------------------------------------------------===//

mlir/include/mlir/Bytecode/BytecodeOpInterface.td

@@ -40,4 +40,28 @@ def BytecodeOpInterface : OpInterface<"BytecodeOpInterface"> {
   ];
 }
 
+// `FallbackBytecodeOpInterface`
+def FallbackBytecodeOpInterface : OpInterface<"FallbackBytecodeOpInterface"> {
+  let description = [{
+    This interface allows fallback operations direct access to the bytecode
+    property streams.
+  }];
+  let cppNamespace = "::mlir";
+
+  let methods = [
+    StaticInterfaceMethod<[{
+      Read the properties blob for this operation from the bytecode and populate the state.
+      }],
+      "LogicalResult", "readPropertiesBlob", (ins
+          "ArrayRef<char>":$blob,
+          "::mlir::OperationState &":$state)
+    >,
+    InterfaceMethod<[{
+      Get the properties blob for this operation to be emitted into the bytecode.
+      }],
+      "ArrayRef<char>", "getPropertiesBlob", (ins)
+    >,
+  ];
+}
+
 #endif // MLIR_BYTECODE_BYTECODEOPINTERFACES

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

@@ -1106,13 +1106,18 @@ class PropertiesSectionReader {
               dialectReader.withEncodingReader(reader).readBlob(rawProperties)))
         return failure();
     }
+
+    // If the op is a "fallback" op, give it a handle to the raw properties
+    // buffer.
+    if (auto *iface = opName->getInterface<FallbackBytecodeOpInterface>())
+      return iface->readPropertiesBlob(rawProperties, opState);
+
     // Setup a new reader to read from the `rawProperties` sub-buffer.
     EncodingReader reader(
         StringRef(rawProperties.begin(), rawProperties.size()), fileLoc);
     DialectReader propReader = dialectReader.withEncodingReader(reader);
 
-    auto *iface = opName->getInterface<BytecodeOpInterface>();
-    if (iface)
+    if (auto *iface = opName->getInterface<BytecodeOpInterface>())
       return iface->readProperties(propReader, opState);
     if (opName->isRegistered())
       return propReader.emitError(
@@ -1506,7 +1511,7 @@ class mlir::BytecodeReader::Impl {
     UseListOrderStorage(bool isIndexPairEncoding,
                         SmallVector<unsigned, 4> &&indices)
         : indices(std::move(indices)),
-          isIndexPairEncoding(isIndexPairEncoding){};
+          isIndexPairEncoding(isIndexPairEncoding) {};
     /// The vector containing the information required to reorder the
     /// use-list of a value.
     SmallVector<unsigned, 4> indices;
@@ -1863,10 +1868,18 @@ BytecodeReader::Impl::parseOpName(EncodingReader &reader,
       // Load the dialect and its version.
       DialectReader dialectReader(attrTypeReader, stringReader, resourceReader,
                                   dialectsMap, reader, version);
-      if (failed(opName->dialect->load(dialectReader, getContext())))
+      if (succeeded(opName->dialect->load(dialectReader, getContext()))) {
+        opName->opName.emplace(
+            (opName->dialect->name + "." + opName->name).str(), getContext());
+      } else if (auto fallbackOp =
+                     opName->dialect->interface->getFallbackOperationName();
+                 succeeded(fallbackOp)) {
+        // If the dialect's bytecode interface specifies a fallback op, we want
+        // to use that instead of an unregistered op.
+        opName->opName.emplace(*fallbackOp);
+      } else {
         return failure();
-      opName->opName.emplace((opName->dialect->name + "." + opName->name).str(),
-                             getContext());
+      }
     }
   }
   return *opName->opName;

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

@@ -518,6 +518,13 @@ class PropertiesSectionBuilder {
       return emit(scratch);
     }
 
+    if (auto iface = dyn_cast<FallbackBytecodeOpInterface>(op)) {
+      // Fallback ops should write the properties payload to the bytecode buffer
+      // directly.
+      ArrayRef<char> encodedProperties = iface.getPropertiesBlob();
+      return emit(encodedProperties);
+    }
+
     EncodingEmitter emitter;
     DialectWriter propertiesWriter(config.bytecodeVersion, emitter,
                                    numberingState, stringSection,