[mlir][spirv] NFC: split deserialization into multiple source files

[antiagainst]

Summary

This avoids large source files and gives a better structure. It also
allows leveraging compilation parallelism.

[ergawy]

Nice! Actually last Friday I was looking into seeing whether doing the same would be beneficial for SPIRVOps.cpp. Using -ftime-trace shows that it takes ~19 seconds to cleanly compile it. Most of that time ~13 is spent in the backend. So I guess parallelized compilation can be beneficial here as well. If you aren't planning to do that already, I can split it.

[antiagainst]

In D94360#2489436, @ergawy wrote:

Nice! Actually last Friday I was looking into seeing whether doing the same would be beneficial for SPIRVOps.cpp. Using -ftime-trace shows that it takes ~19 seconds to cleanly compile it. Most of that time ~13 is spent in the backend. So I guess parallelized compilation can be beneficial here as well. If you aren't planning to do that already, I can split it.

Yup! That is another large file that should be split into multiple smaller ones. Please feel free to take on it if you are interested! We can split according op categories, like we do with those td files. Or some other scheme that you'd like. Thanks a lot! :D

mlir/lib/Target/CMakeLists.txt

+add_subdirectory(SPIRV)
+
 add_mlir_translation_library(MLIRTargetLLVMIRModuleTranslation
   LLVMIR/DebugTranslation.cpp
   LLVMIR/ModuleTranslation.cpp
   LLVMIR/TypeTranslation.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
 
add_mlir_translation_library(MLIRTargetROCDLIR
 
   LINK_LIBS PUBLIC
   MLIRGPU
   MLIRIR
   MLIRLLVMIR
   MLIRROCDLIR
   MLIRTargetLLVMIRModuleTranslation
   )
-
-add_mlir_translation_library(MLIRSPIRVBinaryUtils
-  SPIRV/SPIRVBinaryUtils.cpp
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSPIRV
-  MLIRSupport
-  )
-
-add_mlir_translation_library(MLIRSPIRVSerialization
-  SPIRV/Serialization.cpp
-
-  DEPENDS
-  MLIRSPIRVSerializationGen
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSPIRV
-  MLIRSPIRVBinaryUtils
-  MLIRSupport
-  MLIRTranslation
-  )
-
-add_mlir_translation_library(MLIRSPIRVDeserialization
-  SPIRV/Deserialization.cpp
-
-  DEPENDS
-  MLIRSPIRVSerializationGen
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSPIRV
-  MLIRSPIRVBinaryUtils
-  MLIRSupport
-  MLIRTranslation
-  )
-
-add_mlir_translation_library(MLIRSPIRVTranslateRegistration
-  SPIRV/TranslateRegistration.cpp
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSPIRV
-  MLIRSPIRVSerialization
-  MLIRSPIRVDeserialization
-  MLIRSupport
-  MLIRTranslation
-  )

mlir/lib/Target/SPIRV/CMakeLists.txt

+add_subdirectory(Deserialization)
+add_subdirectory(Serialization)
+
+set(LLVM_OPTIONAL_SOURCES
+  SPIRVBinaryUtils.cpp
+  TranslateRegistration.cpp
+  )
+
+add_mlir_translation_library(MLIRSPIRVBinaryUtils
+  SPIRVBinaryUtils.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSPIRV
+  MLIRSupport
+  )
+
+add_mlir_translation_library(MLIRSPIRVTranslateRegistration
+  TranslateRegistration.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSPIRV
+  MLIRSPIRVSerialization
+  MLIRSPIRVDeserialization
+  MLIRSupport
+  MLIRTranslation
+  )

mlir/lib/Target/SPIRV/Deserialization/CMakeLists.txt

+add_mlir_translation_library(MLIRSPIRVDeserialization
+  DeserializeOps.cpp
+  Deserializer.cpp
+  Deserialization.cpp
+
+  DEPENDS
+  MLIRSPIRVSerializationGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSPIRV
+  MLIRSPIRVBinaryUtils
+  MLIRSupport
+  MLIRTranslation
+  )
+
+

mlir/lib/Target/SPIRV/Deserialization/Deserialization.cpp

+//===- Deserialization.cpp - MLIR SPIR-V Deserialization ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Target/SPIRV/Deserialization.h"
+
+#include "Deserializer.h"
+
+namespace mlir {
+spirv::OwningSPIRVModuleRef spirv::deserialize(ArrayRef<uint32_t> binary,
+                                               MLIRContext *context) {
+  Deserializer deserializer(binary, context);
+
+  if (failed(deserializer.deserialize()))
+    return nullptr;
+
+  return deserializer.collect();
+}
+} // namespace mlir

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

+//===- DeserializeOps.cpp - MLIR SPIR-V Deserialization (Ops) -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the Deserializer methods for SPIR-V binary instructions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Deserializer.h"
+
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Location.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Debug.h"
+
+using namespace mlir;
+
+#define DEBUG_TYPE "spirv-deserialization"
+
+//===----------------------------------------------------------------------===//
+// Utility Functions
+//===----------------------------------------------------------------------===//
+
+/// Extracts the opcode from the given first word of a SPIR-V instruction.
+static inline spirv::Opcode extractOpcode(uint32_t word) {
+  return static_cast<spirv::Opcode>(word & 0xffff);
+}
+
+//===----------------------------------------------------------------------===//
+// Instruction
+//===----------------------------------------------------------------------===//
+
+Value spirv::Deserializer::getValue(uint32_t id) {
+  if (auto constInfo = getConstant(id)) {
+    // Materialize a `spv.constant` op at every use site.
+    return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second,
+                                               constInfo->first);
+  }
+  if (auto varOp = getGlobalVariable(id)) {
+    auto addressOfOp = opBuilder.create<spirv::AddressOfOp>(
+        unknownLoc, varOp.type(),
+        opBuilder.getSymbolRefAttr(varOp.getOperation()));
+    return addressOfOp.pointer();
+  }
+  if (auto constOp = getSpecConstant(id)) {
+    auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
+        unknownLoc, constOp.default_value().getType(),
+        opBuilder.getSymbolRefAttr(constOp.getOperation()));
+    return referenceOfOp.reference();
+  }
+  if (auto constCompositeOp = getSpecConstantComposite(id)) {
+    auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
+        unknownLoc, constCompositeOp.type(),
+        opBuilder.getSymbolRefAttr(constCompositeOp.getOperation()));
+    return referenceOfOp.reference();
+  }
+  if (auto undef = getUndefType(id)) {
+    return opBuilder.create<spirv::UndefOp>(unknownLoc, undef);
+  }
+  return valueMap.lookup(id);
+}
+
+LogicalResult
+spirv::Deserializer::sliceInstruction(spirv::Opcode &opcode,
+                                      ArrayRef<uint32_t> &operands,
+                                      Optional<spirv::Opcode> expectedOpcode) {
+  auto binarySize = binary.size();
+  if (curOffset >= binarySize) {
+    return emitError(unknownLoc, "expected ")
+           << (expectedOpcode ? spirv::stringifyOpcode(*expectedOpcode)
+                              : "more")
+           << " instruction";
+  }
+
+  // For each instruction, get its word count from the first word to slice it
+  // from the stream properly, and then dispatch to the instruction handler.
+
+  uint32_t wordCount = binary[curOffset] >> 16;
+
+  if (wordCount == 0)
+    return emitError(unknownLoc, "word count cannot be zero");
+
+  uint32_t nextOffset = curOffset + wordCount;
+  if (nextOffset > binarySize)
+    return emitError(unknownLoc, "insufficient words for the last instruction");
+
+  opcode = extractOpcode(binary[curOffset]);
+  operands = binary.slice(curOffset + 1, wordCount - 1);
+  curOffset = nextOffset;
+  return success();
+}
+
+LogicalResult spirv::Deserializer::processInstruction(
+    spirv::Opcode opcode, ArrayRef<uint32_t> operands, bool deferInstructions) {
+  LLVM_DEBUG(llvm::dbgs() << "[inst] processing instruction "
+                          << spirv::stringifyOpcode(opcode) << "\n");
+
+  // First dispatch all the instructions whose opcode does not correspond to
+  // those that have a direct mirror in the SPIR-V dialect
+  switch (opcode) {
+  case spirv::Opcode::OpCapability:
+    return processCapability(operands);
+  case spirv::Opcode::OpExtension:
+    return processExtension(operands);
+  case spirv::Opcode::OpExtInst:
+    return processExtInst(operands);
+  case spirv::Opcode::OpExtInstImport:
+    return processExtInstImport(operands);
+  case spirv::Opcode::OpMemberName:
+    return processMemberName(operands);
+  case spirv::Opcode::OpMemoryModel:
+    return processMemoryModel(operands);
+  case spirv::Opcode::OpEntryPoint:
+  case spirv::Opcode::OpExecutionMode:
+    if (deferInstructions) {
+      deferredInstructions.emplace_back(opcode, operands);
+      return success();
+    }
+    break;
+  case spirv::Opcode::OpVariable:
+    if (isa<spirv::ModuleOp>(opBuilder.getBlock()->getParentOp())) {
+      return processGlobalVariable(operands);
+    }
+    break;
+  case spirv::Opcode::OpLine:
+    return processDebugLine(operands);
+  case spirv::Opcode::OpNoLine:
+    return clearDebugLine();
+  case spirv::Opcode::OpName:
+    return processName(operands);
+  case spirv::Opcode::OpString:
+    return processDebugString(operands);
+  case spirv::Opcode::OpModuleProcessed:
+  case spirv::Opcode::OpSource:
+  case spirv::Opcode::OpSourceContinued:
+  case spirv::Opcode::OpSourceExtension:
+    // TODO: This is debug information embedded in the binary which should be
+    // translated into the spv.module.
+    return success();
+  case spirv::Opcode::OpTypeVoid:
+  case spirv::Opcode::OpTypeBool:
+  case spirv::Opcode::OpTypeInt:
+  case spirv::Opcode::OpTypeFloat:
+  case spirv::Opcode::OpTypeVector:
+  case spirv::Opcode::OpTypeMatrix:
+  case spirv::Opcode::OpTypeArray:
+  case spirv::Opcode::OpTypeFunction:
+  case spirv::Opcode::OpTypeRuntimeArray:
+  case spirv::Opcode::OpTypeStruct:
+  case spirv::Opcode::OpTypePointer:
+  case spirv::Opcode::OpTypeCooperativeMatrixNV:
+    return processType(opcode, operands);
+  case spirv::Opcode::OpTypeForwardPointer:
+    return processTypeForwardPointer(operands);
+  case spirv::Opcode::OpConstant:
+    return processConstant(operands, /*isSpec=*/false);
+  case spirv::Opcode::OpSpecConstant:
+    return processConstant(operands, /*isSpec=*/true);
+  case spirv::Opcode::OpConstantComposite:
+    return processConstantComposite(operands);
+  case spirv::Opcode::OpSpecConstantComposite:
+    return processSpecConstantComposite(operands);
+  case spirv::Opcode::OpConstantTrue:
+    return processConstantBool(/*isTrue=*/true, operands, /*isSpec=*/false);
+  case spirv::Opcode::OpSpecConstantTrue:
+    return processConstantBool(/*isTrue=*/true, operands, /*isSpec=*/true);
+  case spirv::Opcode::OpConstantFalse:
+    return processConstantBool(/*isTrue=*/false, operands, /*isSpec=*/false);
+  case spirv::Opcode::OpSpecConstantFalse:
+    return processConstantBool(/*isTrue=*/false, operands, /*isSpec=*/true);
+  case spirv::Opcode::OpConstantNull:
+    return processConstantNull(operands);
+  case spirv::Opcode::OpDecorate:
+    return processDecoration(operands);
+  case spirv::Opcode::OpMemberDecorate:
+    return processMemberDecoration(operands);
+  case spirv::Opcode::OpFunction:
+    return processFunction(operands);
+  case spirv::Opcode::OpLabel:
+    return processLabel(operands);
+  case spirv::Opcode::OpBranch:
+    return processBranch(operands);
+  case spirv::Opcode::OpBranchConditional:
+    return processBranchConditional(operands);
+  case spirv::Opcode::OpSelectionMerge:
+    return processSelectionMerge(operands);
+  case spirv::Opcode::OpLoopMerge:
+    return processLoopMerge(operands);
+  case spirv::Opcode::OpPhi:
+    return processPhi(operands);
+  case spirv::Opcode::OpUndef:
+    return processUndef(operands);
+  default:
+    break;
+  }
+  return dispatchToAutogenDeserialization(opcode, operands);
+}
+
+LogicalResult spirv::Deserializer::processOpWithoutGrammarAttr(
+    ArrayRef<uint32_t> words, StringRef opName, bool hasResult,
+    unsigned numOperands) {
+  SmallVector<Type, 1> resultTypes;
+  uint32_t valueID = 0;
+
+  size_t wordIndex = 0;
+  if (hasResult) {
+    if (wordIndex >= words.size())
+      return emitError(unknownLoc,
+                       "expected result type <id> while deserializing for ")
+             << opName;
+
+    // Decode the type <id>
+    auto type = getType(words[wordIndex]);
+    if (!type)
+      return emitError(unknownLoc, "unknown type result <id>: ")
+             << words[wordIndex];
+    resultTypes.push_back(type);
+    ++wordIndex;
+
+    // Decode the result <id>
+    if (wordIndex >= words.size())
+      return emitError(unknownLoc,
+                       "expected result <id> while deserializing for ")
+             << opName;
+    valueID = words[wordIndex];
+    ++wordIndex;
+  }
+
+  SmallVector<Value, 4> operands;
+  SmallVector<NamedAttribute, 4> attributes;
+
+  // Decode operands
+  size_t operandIndex = 0;
+  for (; operandIndex < numOperands && wordIndex < words.size();
+       ++operandIndex, ++wordIndex) {
+    auto arg = getValue(words[wordIndex]);
+    if (!arg)
+      return emitError(unknownLoc, "unknown result <id>: ") << words[wordIndex];
+    operands.push_back(arg);
+  }
+  if (operandIndex != numOperands) {
+    return emitError(
+               unknownLoc,
+               "found less operands than expected when deserializing for ")
+           << opName << "; only " << operandIndex << " of " << numOperands
+           << " processed";
+  }
+  if (wordIndex != words.size()) {
+    return emitError(
+               unknownLoc,
+               "found more operands than expected when deserializing for ")
+           << opName << "; only " << wordIndex << " of " << words.size()
+           << " processed";
+  }
+
+  // Attach attributes from decorations
+  if (decorations.count(valueID)) {
+    auto attrs = decorations[valueID].getAttrs();
+    attributes.append(attrs.begin(), attrs.end());
+  }
+
+  // Create the op and update bookkeeping maps
+  Location loc = createFileLineColLoc(opBuilder);
+  OperationState opState(loc, opName);
+  opState.addOperands(operands);
+  if (hasResult)
+    opState.addTypes(resultTypes);
+  opState.addAttributes(attributes);
+  Operation *op = opBuilder.createOperation(opState);
+  if (hasResult)
+    valueMap[valueID] = op->getResult(0);
+
+  if (op->hasTrait<OpTrait::IsTerminator>())
+    clearDebugLine();
+
+  return success();
+}
+
+LogicalResult spirv::Deserializer::processUndef(ArrayRef<uint32_t> operands) {
+  if (operands.size() != 2) {
+    return emitError(unknownLoc, "OpUndef instruction must have two operands");
+  }
+  auto type = getType(operands[0]);
+  if (!type) {
+    return emitError(unknownLoc, "unknown type <id> with OpUndef instruction");
+  }
+  undefMap[operands[1]] = type;
+  return success();
+}
+
+LogicalResult spirv::Deserializer::processExtInst(ArrayRef<uint32_t> operands) {
+  if (operands.size() < 4) {
+    return emitError(unknownLoc,
+                     "OpExtInst must have at least 4 operands, result type "
+                     "<id>, result <id>, set <id> and instruction opcode");
+  }
+  if (!extendedInstSets.count(operands[2])) {
+    return emitError(unknownLoc, "undefined set <id> in OpExtInst");
+  }
+  SmallVector<uint32_t, 4> slicedOperands;
+  slicedOperands.append(operands.begin(), std::next(operands.begin(), 2));
+  slicedOperands.append(std::next(operands.begin(), 4), operands.end());
+  return dispatchToExtensionSetAutogenDeserialization(
+      extendedInstSets[operands[2]], operands[3], slicedOperands);
+}
+
+namespace mlir {
+namespace spirv {
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::EntryPointOp>(ArrayRef<uint32_t> words) {
+  unsigned wordIndex = 0;
+  if (wordIndex >= words.size()) {
+    return emitError(unknownLoc,
+                     "missing Execution Model specification in OpEntryPoint");
+  }
+  auto execModel = opBuilder.getI32IntegerAttr(words[wordIndex++]);
+  if (wordIndex >= words.size()) {
+    return emitError(unknownLoc, "missing <id> in OpEntryPoint");
+  }
+  // Get the function <id>
+  auto fnID = words[wordIndex++];
+  // Get the function name
+  auto fnName = decodeStringLiteral(words, wordIndex);
+  // Verify that the function <id> matches the fnName
+  auto parsedFunc = getFunction(fnID);
+  if (!parsedFunc) {
+    return emitError(unknownLoc, "no function matching <id> ") << fnID;
+  }
+  if (parsedFunc.getName() != fnName) {
+    return emitError(unknownLoc, "function name mismatch between OpEntryPoint "
+                                 "and OpFunction with <id> ")
+           << fnID << ": " << fnName << " vs. " << parsedFunc.getName();
+  }
+  SmallVector<Attribute, 4> interface;
+  while (wordIndex < words.size()) {
+    auto arg = getGlobalVariable(words[wordIndex]);
+    if (!arg) {
+      return emitError(unknownLoc, "undefined result <id> ")
+             << words[wordIndex] << " while decoding OpEntryPoint";
+    }
+    interface.push_back(opBuilder.getSymbolRefAttr(arg.getOperation()));
+    wordIndex++;
+  }
+  opBuilder.create<spirv::EntryPointOp>(unknownLoc, execModel,
+                                        opBuilder.getSymbolRefAttr(fnName),
+                                        opBuilder.getArrayAttr(interface));
+  return success();
+}
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::ExecutionModeOp>(ArrayRef<uint32_t> words) {
+  unsigned wordIndex = 0;
+  if (wordIndex >= words.size()) {
+    return emitError(unknownLoc,
+                     "missing function result <id> in OpExecutionMode");
+  }
+  // Get the function <id> to get the name of the function
+  auto fnID = words[wordIndex++];
+  auto fn = getFunction(fnID);
+  if (!fn) {
+    return emitError(unknownLoc, "no function matching <id> ") << fnID;
+  }
+  // Get the Execution mode
+  if (wordIndex >= words.size()) {
+    return emitError(unknownLoc, "missing Execution Mode in OpExecutionMode");
+  }
+  auto execMode = opBuilder.getI32IntegerAttr(words[wordIndex++]);
+
+  // Get the values
+  SmallVector<Attribute, 4> attrListElems;
+  while (wordIndex < words.size()) {
+    attrListElems.push_back(opBuilder.getI32IntegerAttr(words[wordIndex++]));
+  }
+  auto values = opBuilder.getArrayAttr(attrListElems);
+  opBuilder.create<spirv::ExecutionModeOp>(
+      unknownLoc, opBuilder.getSymbolRefAttr(fn.getName()), execMode, values);
+  return success();
+}
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::ControlBarrierOp>(ArrayRef<uint32_t> operands) {
+  if (operands.size() != 3) {
+    return emitError(
+        unknownLoc,
+        "OpControlBarrier must have execution scope <id>, memory scope <id> "
+        "and memory semantics <id>");
+  }
+
+  SmallVector<IntegerAttr, 3> argAttrs;
+  for (auto operand : operands) {
+    auto argAttr = getConstantInt(operand);
+    if (!argAttr) {
+      return emitError(unknownLoc,
+                       "expected 32-bit integer constant from <id> ")
+             << operand << " for OpControlBarrier";
+    }
+    argAttrs.push_back(argAttr);
+  }
+
+  opBuilder.create<spirv::ControlBarrierOp>(unknownLoc, argAttrs[0],
+                                            argAttrs[1], argAttrs[2]);
+  return success();
+}
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::FunctionCallOp>(ArrayRef<uint32_t> operands) {
+  if (operands.size() < 3) {
+    return emitError(unknownLoc,
+                     "OpFunctionCall must have at least 3 operands");
+  }
+
+  Type resultType = getType(operands[0]);
+  if (!resultType) {
+    return emitError(unknownLoc, "undefined result type from <id> ")
+           << operands[0];
+  }
+
+  // Use null type to mean no result type.
+  if (isVoidType(resultType))
+    resultType = nullptr;
+
+  auto resultID = operands[1];
+  auto functionID = operands[2];
+
+  auto functionName = getFunctionSymbol(functionID);
+
+  SmallVector<Value, 4> arguments;
+  for (auto operand : llvm::drop_begin(operands, 3)) {
+    auto value = getValue(operand);
+    if (!value) {
+      return emitError(unknownLoc, "unknown <id> ")
+             << operand << " used by OpFunctionCall";
+    }
+    arguments.push_back(value);
+  }
+
+  auto opFunctionCall = opBuilder.create<spirv::FunctionCallOp>(
+      unknownLoc, resultType, opBuilder.getSymbolRefAttr(functionName),
+      arguments);
+
+  if (resultType)
+    valueMap[resultID] = opFunctionCall.getResult(0);
+  return success();
+}
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::MemoryBarrierOp>(ArrayRef<uint32_t> operands) {
+  if (operands.size() != 2) {
+    return emitError(unknownLoc, "OpMemoryBarrier must have memory scope <id> "
+                                 "and memory semantics <id>");
+  }
+
+  SmallVector<IntegerAttr, 2> argAttrs;
+  for (auto operand : operands) {
+    auto argAttr = getConstantInt(operand);
+    if (!argAttr) {
+      return emitError(unknownLoc,
+                       "expected 32-bit integer constant from <id> ")
+             << operand << " for OpMemoryBarrier";
+    }
+    argAttrs.push_back(argAttr);
+  }
+
+  opBuilder.create<spirv::MemoryBarrierOp>(unknownLoc, argAttrs[0],
+                                           argAttrs[1]);
+  return success();
+}
+
+template <>
+LogicalResult
+Deserializer::processOp<spirv::CopyMemoryOp>(ArrayRef<uint32_t> words) {
+  SmallVector<Type, 1> resultTypes;
+  size_t wordIndex = 0;
+  SmallVector<Value, 4> operands;
+  SmallVector<NamedAttribute, 4> attributes;
+
+  if (wordIndex < words.size()) {
+    auto arg = getValue(words[wordIndex]);
+
+    if (!arg) {
+      return emitError(unknownLoc, "unknown result <id> : ")
+             << words[wordIndex];
+    }
+
+    operands.push_back(arg);
+    wordIndex++;
+  }
+
+  if (wordIndex < words.size()) {
+    auto arg = getValue(words[wordIndex]);
+
+    if (!arg) {
+      return emitError(unknownLoc, "unknown result <id> : ")
+             << words[wordIndex];
+    }
+
+    operands.push_back(arg);
+    wordIndex++;
+  }
+
+  bool isAlignedAttr = false;
+
+  if (wordIndex < words.size()) {
+    auto attrValue = words[wordIndex++];
+    attributes.push_back(opBuilder.getNamedAttr(
+        "memory_access", opBuilder.getI32IntegerAttr(attrValue)));
+    isAlignedAttr = (attrValue == 2);
+  }
+
+  if (isAlignedAttr && wordIndex < words.size()) {
+    attributes.push_back(opBuilder.getNamedAttr(
+        "alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
+  }
+
+  if (wordIndex < words.size()) {
+    attributes.push_back(opBuilder.getNamedAttr(
+        "source_memory_access",
+        opBuilder.getI32IntegerAttr(words[wordIndex++])));
+  }
+
+  if (wordIndex < words.size()) {
+    attributes.push_back(opBuilder.getNamedAttr(
+        "source_alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
+  }
+
+  if (wordIndex != words.size()) {
+    return emitError(unknownLoc,
+                     "found more operands than expected when deserializing "
+                     "spirv::CopyMemoryOp, only ")
+           << wordIndex << " of " << words.size() << " processed";
+  }
+
+  Location loc = createFileLineColLoc(opBuilder);
+  opBuilder.create<spirv::CopyMemoryOp>(loc, resultTypes, operands, attributes);
+
+  return success();
+}
+
+// Pull in auto-generated Deserializer::dispatchToAutogenDeserialization() and
+// various Deserializer::processOp<...>() specializations.
+#define GET_DESERIALIZATION_FNS
+#include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
+
+} // namespace spirv
+} // namespace mlir

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

+//===- Deserializer.h - MLIR SPIR-V Deserializer ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the SPIR-V binary to MLIR SPIR-V module deserializer.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_SPIRV_DESERIALIZER_H
+#define MLIR_TARGET_SPIRV_DESERIALIZER_H
+
+#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/IR/Builders.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/StringRef.h"
+#include <cstdint>
+
+//===----------------------------------------------------------------------===//
+// Utility Functions
+//===----------------------------------------------------------------------===//
+
+/// Decodes a string literal in `words` starting at `wordIndex`. Update the
+/// latter to point to the position in words after the string literal.
+static inline llvm::StringRef
+decodeStringLiteral(llvm::ArrayRef<uint32_t> words, unsigned &wordIndex) {
+  llvm::StringRef str(reinterpret_cast<const char *>(words.data() + wordIndex));
+  wordIndex += str.size() / 4 + 1;
+  return str;
+}
+
+namespace mlir {
+namespace spirv {
+
+//===----------------------------------------------------------------------===//
+// Utility Definitions
+//===----------------------------------------------------------------------===//
+
+/// A struct for containing a header block's merge and continue targets.
+///
+/// This struct is used to track original structured control flow info from
+/// SPIR-V blob. This info will be used to create spv.selection/spv.loop
+/// later.
+struct BlockMergeInfo {
+  Block *mergeBlock;
+  Block *continueBlock; // nullptr for spv.selection
+  Location loc;
+  uint32_t control;
+
+  BlockMergeInfo(Location location, uint32_t control)
+      : mergeBlock(nullptr), continueBlock(nullptr), loc(location),
+        control(control) {}
+  BlockMergeInfo(Location location, uint32_t control, Block *m,
+                 Block *c = nullptr)
+      : mergeBlock(m), continueBlock(c), loc(location), control(control) {}
+};
+
+/// A struct for containing OpLine instruction information.
+struct DebugLine {
+  uint32_t fileID;
+  uint32_t line;
+  uint32_t col;
+
+  DebugLine(uint32_t fileIDNum, uint32_t lineNum, uint32_t colNum)
+      : fileID(fileIDNum), line(lineNum), col(colNum) {}
+};
+
+/// Map from a selection/loop's header block to its merge (and continue) target.
+using BlockMergeInfoMap = DenseMap<Block *, BlockMergeInfo>;
+
+/// A "deferred struct type" is a struct type with one or more member types not
+/// known when the Deserializer first encounters the struct. This happens, for
+/// example, with recursive structs where a pointer to the struct type is
+/// forward declared through OpTypeForwardPointer in the SPIR-V module before
+/// the struct declaration; the actual pointer to struct type should be defined
+/// later through an OpTypePointer. For example, the following C struct:
+///
+/// struct A {
+///   A* next;
+/// };
+///
+/// would be represented in the SPIR-V module as:
+///
+/// OpName %A "A"
+/// OpTypeForwardPointer %APtr Generic
+/// %A = OpTypeStruct %APtr
+/// %APtr = OpTypePointer Generic %A
+///
+/// This means that the spirv::StructType cannot be fully constructed directly
+/// when the Deserializer encounters it. Instead we create a
+/// DeferredStructTypeInfo that contains all the information we know about the
+/// spirv::StructType. Once all forward references for the struct are resolved,
+/// the struct's body is set with all member info.
+struct DeferredStructTypeInfo {
+  spirv::StructType deferredStructType;
+
+  // A list of all unresolved member types for the struct. First element of each
+  // item is operand ID, second element is member index in the struct.
+  SmallVector<std::pair<uint32_t, unsigned>, 0> unresolvedMemberTypes;
+
+  // The list of member types. For unresolved members, this list contains
+  // place-holder empty types that will be updated later.
+  SmallVector<Type, 4> memberTypes;
+  SmallVector<spirv::StructType::OffsetInfo, 0> offsetInfo;
+  SmallVector<spirv::StructType::MemberDecorationInfo, 0> memberDecorationsInfo;
+};
+
+//===----------------------------------------------------------------------===//
+// Deserializer Declaration
+//===----------------------------------------------------------------------===//
+
+/// A SPIR-V module serializer.
+///
+/// A SPIR-V binary module is a single linear stream of instructions; each
+/// instruction is composed of 32-bit words. The first word of an instruction
+/// records the total number of words of that instruction using the 16
+/// higher-order bits. So this deserializer uses that to get instruction
+/// boundary and parse instructions and build a SPIR-V ModuleOp gradually.
+///
+// TODO: clean up created ops on errors
+class Deserializer {
+public:
+  /// Creates a deserializer for the given SPIR-V `binary` module.
+  /// The SPIR-V ModuleOp will be created into `context.
+  explicit Deserializer(ArrayRef<uint32_t> binary, MLIRContext *context);
+
+  /// Deserializes the remembered SPIR-V binary module.
+  LogicalResult deserialize();
+
+  /// Collects the final SPIR-V ModuleOp.
+  spirv::OwningSPIRVModuleRef collect();
+
+private:
+  //===--------------------------------------------------------------------===//
+  // Module structure
+  //===--------------------------------------------------------------------===//
+
+  /// Initializes the `module` ModuleOp in this deserializer instance.
+  spirv::OwningSPIRVModuleRef createModuleOp();
+
+  /// Processes SPIR-V module header in `binary`.
+  LogicalResult processHeader();
+
+  /// Processes the SPIR-V OpCapability with `operands` and updates bookkeeping
+  /// in the deserializer.
+  LogicalResult processCapability(ArrayRef<uint32_t> operands);
+
+  /// Processes the SPIR-V OpExtension with `operands` and updates bookkeeping
+  /// in the deserializer.
+  LogicalResult processExtension(ArrayRef<uint32_t> words);
+
+  /// Processes the SPIR-V OpExtInstImport with `operands` and updates
+  /// bookkeeping in the deserializer.
+  LogicalResult processExtInstImport(ArrayRef<uint32_t> words);
+
+  /// Attaches (version, capabilities, extensions) triple to `module` as an
+  /// attribute.
+  void attachVCETriple();
+
+  /// Processes the SPIR-V OpMemoryModel with `operands` and updates `module`.
+  LogicalResult processMemoryModel(ArrayRef<uint32_t> operands);
+
+  /// Process SPIR-V OpName with `operands`.
+  LogicalResult processName(ArrayRef<uint32_t> operands);
+
+  /// Processes an OpDecorate instruction.
+  LogicalResult processDecoration(ArrayRef<uint32_t> words);
+
+  // Processes an OpMemberDecorate instruction.
+  LogicalResult processMemberDecoration(ArrayRef<uint32_t> words);
+
+  /// Processes an OpMemberName instruction.
+  LogicalResult processMemberName(ArrayRef<uint32_t> words);
+
+  /// Gets the function op associated with a result <id> of OpFunction.
+  spirv::FuncOp getFunction(uint32_t id) { return funcMap.lookup(id); }
+
+  /// Processes the SPIR-V function at the current `offset` into `binary`.
+  /// The operands to the OpFunction instruction is passed in as ``operands`.
+  /// This method processes each instruction inside the function and dispatches
+  /// them to their handler method accordingly.
+  LogicalResult processFunction(ArrayRef<uint32_t> operands);
+
+  /// Processes OpFunctionEnd and finalizes function. This wires up block
+  /// argument created from OpPhi instructions and also structurizes control
+  /// flow.
+  LogicalResult processFunctionEnd(ArrayRef<uint32_t> operands);
+
+  /// Gets the constant's attribute and type associated with the given <id>.
+  Optional<std::pair<Attribute, Type>> getConstant(uint32_t id);
+
+  /// Gets the constant's integer attribute with the given <id>. Returns a null
+  /// IntegerAttr if the given is not registered or does not correspond to an
+  /// integer constant.
+  IntegerAttr getConstantInt(uint32_t id);
+
+  /// Returns a symbol to be used for the function name with the given
+  /// result <id>. This tries to use the function's OpName if
+  /// exists; otherwise creates one based on the <id>.
+  std::string getFunctionSymbol(uint32_t id);
+
+  /// Returns a symbol to be used for the specialization constant with the given
+  /// result <id>. This tries to use the specialization constant's OpName if
+  /// exists; otherwise creates one based on the <id>.
+  std::string getSpecConstantSymbol(uint32_t id);
+
+  /// Gets the specialization constant with the given result <id>.
+  spirv::SpecConstantOp getSpecConstant(uint32_t id) {
+    return specConstMap.lookup(id);
+  }
+
+  /// Gets the composite specialization constant with the given result <id>.
+  spirv::SpecConstantCompositeOp getSpecConstantComposite(uint32_t id) {
+    return specConstCompositeMap.lookup(id);
+  }
+
+  /// Creates a spirv::SpecConstantOp.
+  spirv::SpecConstantOp createSpecConstant(Location loc, uint32_t resultID,
+                                           Attribute defaultValue);
+
+  /// Processes the OpVariable instructions at current `offset` into `binary`.
+  /// It is expected that this method is used for variables that are to be
+  /// defined at module scope and will be deserialized into a spv.globalVariable
+  /// instruction.
+  LogicalResult processGlobalVariable(ArrayRef<uint32_t> operands);
+
+  /// Gets the global variable associated with a result <id> of OpVariable.
+  spirv::GlobalVariableOp getGlobalVariable(uint32_t id) {
+    return globalVariableMap.lookup(id);
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Type
+  //===--------------------------------------------------------------------===//
+
+  /// Gets type for a given result <id>.
+  Type getType(uint32_t id) { return typeMap.lookup(id); }
+
+  /// Get the type associated with the result <id> of an OpUndef.
+  Type getUndefType(uint32_t id) { return undefMap.lookup(id); }
+
+  /// Returns true if the given `type` is for SPIR-V void type.
+  bool isVoidType(Type type) const { return type.isa<NoneType>(); }
+
+  /// Processes a SPIR-V type instruction with given `opcode` and `operands` and
+  /// registers the type into `module`.
+  LogicalResult processType(spirv::Opcode opcode, ArrayRef<uint32_t> operands);
+
+  LogicalResult processOpTypePointer(ArrayRef<uint32_t> operands);
+
+  LogicalResult processArrayType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processCooperativeMatrixType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processFunctionType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processRuntimeArrayType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processStructType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processMatrixType(ArrayRef<uint32_t> operands);
+
+  LogicalResult processTypeForwardPointer(ArrayRef<uint32_t> operands);
+
+  //===--------------------------------------------------------------------===//
+  // Constant
+  //===--------------------------------------------------------------------===//
+
+  /// Processes a SPIR-V Op{|Spec}Constant instruction with the given
+  /// `operands`. `isSpec` indicates whether this is a specialization constant.
+  LogicalResult processConstant(ArrayRef<uint32_t> operands, bool isSpec);
+
+  /// Processes a SPIR-V Op{|Spec}Constant{True|False} instruction with the
+  /// given `operands`. `isSpec` indicates whether this is a specialization
+  /// constant.
+  LogicalResult processConstantBool(bool isTrue, ArrayRef<uint32_t> operands,
+                                    bool isSpec);
+
+  /// Processes a SPIR-V OpConstantComposite instruction with the given
+  /// `operands`.
+  LogicalResult processConstantComposite(ArrayRef<uint32_t> operands);
+
+  LogicalResult processSpecConstantComposite(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpConstantNull instruction with the given `operands`.
+  LogicalResult processConstantNull(ArrayRef<uint32_t> operands);
+
+  //===--------------------------------------------------------------------===//
+  // Debug
+  //===--------------------------------------------------------------------===//
+
+  /// Discontinues any source-level location information that might be active
+  /// from a previous OpLine instruction.
+  LogicalResult clearDebugLine();
+
+  /// Creates a FileLineColLoc with the OpLine location information.
+  Location createFileLineColLoc(OpBuilder opBuilder);
+
+  /// Processes a SPIR-V OpLine instruction with the given `operands`.
+  LogicalResult processDebugLine(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpString instruction with the given `operands`.
+  LogicalResult processDebugString(ArrayRef<uint32_t> operands);
+
+  //===--------------------------------------------------------------------===//
+  // Control flow
+  //===--------------------------------------------------------------------===//
+
+  /// Returns the block for the given label <id>.
+  Block *getBlock(uint32_t id) const { return blockMap.lookup(id); }
+
+  // In SPIR-V, structured control flow is explicitly declared using merge
+  // instructions (OpSelectionMerge and OpLoopMerge). In the SPIR-V dialect,
+  // we use spv.selection and spv.loop to group structured control flow.
+  // The deserializer need to turn structured control flow marked with merge
+  // instructions into using spv.selection/spv.loop ops.
+  //
+  // Because structured control flow can nest and the basic block order have
+  // flexibility, we cannot isolate a structured selection/loop without
+  // deserializing all the blocks. So we use the following approach:
+  //
+  // 1. Deserialize all basic blocks in a function and create MLIR blocks for
+  //    them into the function's region. In the meanwhile, keep a map between
+  //    selection/loop header blocks to their corresponding merge (and continue)
+  //    target blocks.
+  // 2. For each selection/loop header block, recursively get all basic blocks
+  //    reachable (except the merge block) and put them in a newly created
+  //    spv.selection/spv.loop's region. Structured control flow guarantees
+  //    that we enter and exit in structured ways and the construct is nestable.
+  // 3. Put the new spv.selection/spv.loop op at the beginning of the old merge
+  //    block and redirect all branches to the old header block to the old
+  //    merge block (which contains the spv.selection/spv.loop op now).
+
+  /// For OpPhi instructions, we use block arguments to represent them. OpPhi
+  /// encodes a list of (value, predecessor) pairs. At the time of handling the
+  /// block containing an OpPhi instruction, the predecessor block might not be
+  /// processed yet, also the value sent by it. So we need to defer handling
+  /// the block argument from the predecessors. We use the following approach:
+  ///
+  /// 1. For each OpPhi instruction, add a block argument to the current block
+  ///    in construction. Record the block argument in `valueMap` so its uses
+  ///    can be resolved. For the list of (value, predecessor) pairs, update
+  ///    `blockPhiInfo` for bookkeeping.
+  /// 2. After processing all blocks, loop over `blockPhiInfo` to fix up each
+  ///    block recorded there to create the proper block arguments on their
+  ///    terminators.
+
+  /// A data structure for containing a SPIR-V block's phi info. It will be
+  /// represented as block argument in SPIR-V dialect.
+  using BlockPhiInfo =
+      SmallVector<uint32_t, 2>; // The result <id> of the values sent
+
+  /// Gets or creates the block corresponding to the given label <id>. The newly
+  /// created block will always be placed at the end of the current function.
+  Block *getOrCreateBlock(uint32_t id);
+
+  LogicalResult processBranch(ArrayRef<uint32_t> operands);
+
+  LogicalResult processBranchConditional(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpLabel instruction with the given `operands`.
+  LogicalResult processLabel(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpSelectionMerge instruction with the given `operands`.
+  LogicalResult processSelectionMerge(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpLoopMerge instruction with the given `operands`.
+  LogicalResult processLoopMerge(ArrayRef<uint32_t> operands);
+
+  /// Processes a SPIR-V OpPhi instruction with the given `operands`.
+  LogicalResult processPhi(ArrayRef<uint32_t> operands);
+
+  /// Creates block arguments on predecessors previously recorded when handling
+  /// OpPhi instructions.
+  LogicalResult wireUpBlockArgument();
+
+  /// Extracts blocks belonging to a structured selection/loop into a
+  /// spv.selection/spv.loop op. This method iterates until all blocks
+  /// declared as selection/loop headers are handled.
+  LogicalResult structurizeControlFlow();
+
+  //===--------------------------------------------------------------------===//
+  // Instruction
+  //===--------------------------------------------------------------------===//
+
+  /// Get the Value associated with a result <id>.
+  ///
+  /// This method materializes normal constants and inserts "casting" ops
+  /// (`spv.mlir.addressof` and `spv.mlir.referenceof`) to turn an symbol into a
+  /// SSA value for handling uses of module scope constants/variables in
+  /// functions.
+  Value getValue(uint32_t id);
+
+  /// Slices the first instruction out of `binary` and returns its opcode and
+  /// operands via `opcode` and `operands` respectively. Returns failure if
+  /// there is no more remaining instructions (`expectedOpcode` will be used to
+  /// compose the error message) or the next instruction is malformed.
+  LogicalResult
+  sliceInstruction(spirv::Opcode &opcode, ArrayRef<uint32_t> &operands,
+                   Optional<spirv::Opcode> expectedOpcode = llvm::None);
+
+  /// Processes a SPIR-V instruction with the given `opcode` and `operands`.
+  /// This method is the main entrance for handling SPIR-V instruction; it
+  /// checks the instruction opcode and dispatches to the corresponding handler.
+  /// Processing of Some instructions (like OpEntryPoint and OpExecutionMode)
+  /// might need to be deferred, since they contain forward references to <id>s
+  /// in the deserialized binary, but module in SPIR-V dialect expects these to
+  /// be ssa-uses.
+  LogicalResult processInstruction(spirv::Opcode opcode,
+                                   ArrayRef<uint32_t> operands,
+                                   bool deferInstructions = true);
+
+  /// Processes a SPIR-V instruction from the given `operands`. It should
+  /// deserialize into an op with the given `opName` and `numOperands`.
+  /// This method is a generic one for dispatching any SPIR-V ops without
+  /// variadic operands and attributes in TableGen definitions.
+  LogicalResult processOpWithoutGrammarAttr(ArrayRef<uint32_t> words,
+                                            StringRef opName, bool hasResult,
+                                            unsigned numOperands);
+
+  /// Processes a OpUndef instruction. Adds a spv.Undef operation at the current
+  /// insertion point.
+  LogicalResult processUndef(ArrayRef<uint32_t> operands);
+
+  /// Method to dispatch to the specialized deserialization function for an
+  /// operation in SPIR-V dialect that is a mirror of an instruction in the
+  /// SPIR-V spec. This is auto-generated from ODS. Dispatch is handled for
+  /// all operations in SPIR-V dialect that have hasOpcode == 1.
+  LogicalResult dispatchToAutogenDeserialization(spirv::Opcode opcode,
+                                                 ArrayRef<uint32_t> words);
+
+  /// Processes a SPIR-V OpExtInst with given `operands`. This slices the
+  /// entries of `operands` that specify the extended instruction set <id> and
+  /// the instruction opcode. The op deserializer is then invoked using the
+  /// other entries.
+  LogicalResult processExtInst(ArrayRef<uint32_t> operands);
+
+  /// Dispatches the deserialization of extended instruction set operation based
+  /// on the extended instruction set name, and instruction opcode. This is
+  /// autogenerated from ODS.
+  LogicalResult
+  dispatchToExtensionSetAutogenDeserialization(StringRef extensionSetName,
+                                               uint32_t instructionID,
+                                               ArrayRef<uint32_t> words);
+
+  /// Method to deserialize an operation in the SPIR-V dialect that is a mirror
+  /// of an instruction in the SPIR-V spec. This is auto generated if hasOpcode
+  /// == 1 and autogenSerialization == 1 in ODS.
+  template <typename OpTy> LogicalResult processOp(ArrayRef<uint32_t> words) {
+    return emitError(unknownLoc, "unsupported deserialization for ")
+           << OpTy::getOperationName() << " op";
+  }
+
+private:
+  /// The SPIR-V binary module.
+  ArrayRef<uint32_t> binary;
+
+  /// Contains the data of the OpLine instruction which precedes the current
+  /// processing instruction.
+  llvm::Optional<DebugLine> debugLine;
+
+  /// The current word offset into the binary module.
+  unsigned curOffset = 0;
+
+  /// MLIRContext to create SPIR-V ModuleOp into.
+  MLIRContext *context;
+
+  // TODO: create Location subclass for binary blob
+  Location unknownLoc;
+
+  /// The SPIR-V ModuleOp.
+  spirv::OwningSPIRVModuleRef module;
+
+  /// The current function under construction.
+  Optional<spirv::FuncOp> curFunction;
+
+  /// The current block under construction.
+  Block *curBlock = nullptr;
+
+  OpBuilder opBuilder;
+
+  spirv::Version version;
+
+  /// The list of capabilities used by the module.
+  llvm::SmallSetVector<spirv::Capability, 4> capabilities;
+
+  /// The list of extensions used by the module.
+  llvm::SmallSetVector<spirv::Extension, 2> extensions;
+
+  // Result <id> to type mapping.
+  DenseMap<uint32_t, Type> typeMap;
+
+  // Result <id> to constant attribute and type mapping.
+  ///
+  /// In the SPIR-V binary format, all constants are placed in the module and
+  /// shared by instructions at module level and in subsequent functions. But in
+  /// the SPIR-V dialect, we materialize the constant to where it's used in the
+  /// function. So when seeing a constant instruction in the binary format, we
+  /// don't immediately emit a constant op into the module, we keep its value
+  /// (and type) here. Later when it's used, we materialize the constant.
+  DenseMap<uint32_t, std::pair<Attribute, Type>> constantMap;
+
+  // Result <id> to spec constant mapping.
+  DenseMap<uint32_t, spirv::SpecConstantOp> specConstMap;
+
+  // Result <id> to composite spec constant mapping.
+  DenseMap<uint32_t, spirv::SpecConstantCompositeOp> specConstCompositeMap;
+
+  // Result <id> to variable mapping.
+  DenseMap<uint32_t, spirv::GlobalVariableOp> globalVariableMap;
+
+  // Result <id> to function mapping.
+  DenseMap<uint32_t, spirv::FuncOp> funcMap;
+
+  // Result <id> to block mapping.
+  DenseMap<uint32_t, Block *> blockMap;
+
+  // Header block to its merge (and continue) target mapping.
+  BlockMergeInfoMap blockMergeInfo;
+
+  // Block to its phi (block argument) mapping.
+  DenseMap<Block *, BlockPhiInfo> blockPhiInfo;
+
+  // Result <id> to value mapping.
+  DenseMap<uint32_t, Value> valueMap;
+
+  // Mapping from result <id> to undef value of a type.
+  DenseMap<uint32_t, Type> undefMap;
+
+  // Result <id> to name mapping.
+  DenseMap<uint32_t, StringRef> nameMap;
+
+  // Result <id> to debug info mapping.
+  DenseMap<uint32_t, StringRef> debugInfoMap;
+
+  // Result <id> to decorations mapping.
+  DenseMap<uint32_t, NamedAttrList> decorations;
+
+  // Result <id> to type decorations.
+  DenseMap<uint32_t, uint32_t> typeDecorations;
+
+  // Result <id> to member decorations.
+  // decorated-struct-type-<id> ->
+  //    (struct-member-index -> (decoration -> decoration-operands))
+  DenseMap<uint32_t,
+           DenseMap<uint32_t, DenseMap<spirv::Decoration, ArrayRef<uint32_t>>>>
+      memberDecorationMap;
+
+  // Result <id> to member name.
+  // struct-type-<id> -> (struct-member-index -> name)
+  DenseMap<uint32_t, DenseMap<uint32_t, StringRef>> memberNameMap;
+
+  // Result <id> to extended instruction set name.
+  DenseMap<uint32_t, StringRef> extendedInstSets;
+
+  // List of instructions that are processed in a deferred fashion (after an
+  // initial processing of the entire binary). Some operations like
+  // OpEntryPoint, and OpExecutionMode use forward references to function
+  // <id>s. In SPIR-V dialect the corresponding operations (spv.EntryPoint and
+  // spv.ExecutionMode) need these references resolved. So these instructions
+  // are deserialized and stored for processing once the entire binary is
+  // processed.
+  SmallVector<std::pair<spirv::Opcode, ArrayRef<uint32_t>>, 4>
+      deferredInstructions;
+
+  /// A list of IDs for all types forward-declared through OpTypeForwardPointer
+  /// instructions.
+  llvm::SetVector<uint32_t> typeForwardPointerIDs;
+
+  /// A list of all structs which have unresolved member types.
+  SmallVector<DeferredStructTypeInfo, 0> deferredStructTypesInfos;
+};
+
+} // namespace spirv
+} // namespace mlir
+
+#endif // MLIR_TARGET_SPIRV_DESERIALIZER_H

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

-//===- Deserializer.cpp - MLIR SPIR-V Deserialization ---------------------===//
+//===- Deserializer.cpp - MLIR SPIR-V Deserializer ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the SPIR-V binary to MLIR SPIR-V module deserialization.
+// This file defines the SPIR-V binary to MLIR SPIR-V module deserializer.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Target/SPIRV/Deserialization.h"
+#include "Deserializer.h"
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
-#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "spirv-deserialization"
 
 //===----------------------------------------------------------------------===//
 // Utility Functions
 //===----------------------------------------------------------------------===//
 
-/// Decodes a string literal in `words` starting at `wordIndex`. Update the
-/// latter to point to the position in words after the string literal.
-static inline StringRef decodeStringLiteral(ArrayRef<uint32_t> words,
-                                            unsigned &wordIndex) {
-  StringRef str(reinterpret_cast<const char *>(words.data() + wordIndex));
-  wordIndex += str.size() / 4 + 1;
-  return str;
-}
-
-/// Extracts the opcode from the given first word of a SPIR-V instruction.
-static inline spirv::Opcode extractOpcode(uint32_t word) {
-  return static_cast<spirv::Opcode>(word & 0xffff);
-}
-
 /// Returns true if the given `block` is a function entry block.
 static inline bool isFnEntryBlock(Block *block) {
   return block->isEntryBlock() &&
          isa_and_nonnull<spirv::FuncOp>(block->getParentOp());
 }
 
-namespace {
-//===----------------------------------------------------------------------===//
-// Utility Definitions
-//===----------------------------------------------------------------------===//
-
-/// A struct for containing a header block's merge and continue targets.
-///
-/// This struct is used to track original structured control flow info from
-/// SPIR-V blob. This info will be used to create spv.selection/spv.loop
-/// later.
-struct BlockMergeInfo {
-  Block *mergeBlock;
-  Block *continueBlock; // nullptr for spv.selection
-  Location loc;
-  uint32_t control;
-
-  BlockMergeInfo(Location location, uint32_t control)
-      : mergeBlock(nullptr), continueBlock(nullptr), loc(location),
-        control(control) {}
-  BlockMergeInfo(Location location, uint32_t control, Block *m,
-                 Block *c = nullptr)
-      : mergeBlock(m), continueBlock(c), loc(location), control(control) {}
-};
-
-/// A struct for containing OpLine instruction information.
-struct DebugLine {
-  uint32_t fileID;
-  uint32_t line;
-  uint32_t col;
-
-  DebugLine(uint32_t fileIDNum, uint32_t lineNum, uint32_t colNum)
-      : fileID(fileIDNum), line(lineNum), col(colNum) {}
-};
-
-/// Map from a selection/loop's header block to its merge (and continue) target.
-using BlockMergeInfoMap = DenseMap<Block *, BlockMergeInfo>;
-
-/// A "deferred struct type" is a struct type with one or more member types not
-/// known when the Deserializer first encounters the struct. This happens, for
-/// example, with recursive structs where a pointer to the struct type is
-/// forward declared through OpTypeForwardPointer in the SPIR-V module before
-/// the struct declaration; the actual pointer to struct type should be defined
-/// later through an OpTypePointer. For example, the following C struct:
-///
-/// struct A {
-///   A* next;
-/// };
-///
-/// would be represented in the SPIR-V module as:
-///
-/// OpName %A "A"
-/// OpTypeForwardPointer %APtr Generic
-/// %A = OpTypeStruct %APtr
-/// %APtr = OpTypePointer Generic %A
-///
-/// This means that the spirv::StructType cannot be fully constructed directly
-/// when the Deserializer encounters it. Instead we create a
-/// DeferredStructTypeInfo that contains all the information we know about the
-/// spirv::StructType. Once all forward references for the struct are resolved,
-/// the struct's body is set with all member info.
-struct DeferredStructTypeInfo {
-  spirv::StructType deferredStructType;
-
-  // A list of all unresolved member types for the struct. First element of each
-  // item is operand ID, second element is member index in the struct.
-  SmallVector<std::pair<uint32_t, unsigned>, 0> unresolvedMemberTypes;
-
-  // The list of member types. For unresolved members, this list contains
-  // place-holder empty types that will be updated later.
-  SmallVector<Type, 4> memberTypes;
-  SmallVector<spirv::StructType::OffsetInfo, 0> offsetInfo;
-  SmallVector<spirv::StructType::MemberDecorationInfo, 0> memberDecorationsInfo;
-};
-
-//===----------------------------------------------------------------------===//
-// Deserializer Declaration
-//===----------------------------------------------------------------------===//
-
-/// A SPIR-V module serializer.
-///
-/// A SPIR-V binary module is a single linear stream of instructions; each
-/// instruction is composed of 32-bit words. The first word of an instruction
-/// records the total number of words of that instruction using the 16
-/// higher-order bits. So this deserializer uses that to get instruction
-/// boundary and parse instructions and build a SPIR-V ModuleOp gradually.
-///
-// TODO: clean up created ops on errors
-class Deserializer {
-public:
-  /// Creates a deserializer for the given SPIR-V `binary` module.
-  /// The SPIR-V ModuleOp will be created into `context.
-  explicit Deserializer(ArrayRef<uint32_t> binary, MLIRContext *context);
-
-  /// Deserializes the remembered SPIR-V binary module.
-  LogicalResult deserialize();
-
-  /// Collects the final SPIR-V ModuleOp.
-  spirv::OwningSPIRVModuleRef collect();
-
-private:
-  //===--------------------------------------------------------------------===//
-  // Module structure
-  //===--------------------------------------------------------------------===//
-
-  /// Initializes the `module` ModuleOp in this deserializer instance.
-  spirv::OwningSPIRVModuleRef createModuleOp();
-
-  /// Processes SPIR-V module header in `binary`.
-  LogicalResult processHeader();
-
-  /// Processes the SPIR-V OpCapability with `operands` and updates bookkeeping
-  /// in the deserializer.
-  LogicalResult processCapability(ArrayRef<uint32_t> operands);
-
-  /// Processes the SPIR-V OpExtension with `operands` and updates bookkeeping
-  /// in the deserializer.
-  LogicalResult processExtension(ArrayRef<uint32_t> words);
-
-  /// Processes the SPIR-V OpExtInstImport with `operands` and updates
-  /// bookkeeping in the deserializer.
-  LogicalResult processExtInstImport(ArrayRef<uint32_t> words);
-
-  /// Attaches (version, capabilities, extensions) triple to `module` as an
-  /// attribute.
-  void attachVCETriple();
-
-  /// Processes the SPIR-V OpMemoryModel with `operands` and updates `module`.
-  LogicalResult processMemoryModel(ArrayRef<uint32_t> operands);
-
-  /// Process SPIR-V OpName with `operands`.
-  LogicalResult processName(ArrayRef<uint32_t> operands);
-
-  /// Processes an OpDecorate instruction.
-  LogicalResult processDecoration(ArrayRef<uint32_t> words);
-
-  // Processes an OpMemberDecorate instruction.
-  LogicalResult processMemberDecoration(ArrayRef<uint32_t> words);
-
-  /// Processes an OpMemberName instruction.
-  LogicalResult processMemberName(ArrayRef<uint32_t> words);
-
-  /// Gets the function op associated with a result <id> of OpFunction.
-  spirv::FuncOp getFunction(uint32_t id) { return funcMap.lookup(id); }
-
-  /// Processes the SPIR-V function at the current `offset` into `binary`.
-  /// The operands to the OpFunction instruction is passed in as ``operands`.
-  /// This method processes each instruction inside the function and dispatches
-  /// them to their handler method accordingly.
-  LogicalResult processFunction(ArrayRef<uint32_t> operands);
-
-  /// Processes OpFunctionEnd and finalizes function. This wires up block
-  /// argument created from OpPhi instructions and also structurizes control
-  /// flow.
-  LogicalResult processFunctionEnd(ArrayRef<uint32_t> operands);
-
-  /// Gets the constant's attribute and type associated with the given <id>.
-  Optional<std::pair<Attribute, Type>> getConstant(uint32_t id);
-
-  /// Gets the constant's integer attribute with the given <id>. Returns a null
-  /// IntegerAttr if the given is not registered or does not correspond to an
-  /// integer constant.
-  IntegerAttr getConstantInt(uint32_t id);
-
-  /// Returns a symbol to be used for the function name with the given
-  /// result <id>. This tries to use the function's OpName if
-  /// exists; otherwise creates one based on the <id>.
-  std::string getFunctionSymbol(uint32_t id);
-
-  /// Returns a symbol to be used for the specialization constant with the given
-  /// result <id>. This tries to use the specialization constant's OpName if
-  /// exists; otherwise creates one based on the <id>.
-  std::string getSpecConstantSymbol(uint32_t id);
-
-  /// Gets the specialization constant with the given result <id>.
-  spirv::SpecConstantOp getSpecConstant(uint32_t id) {
-    return specConstMap.lookup(id);
-  }
-
-  /// Gets the composite specialization constant with the given result <id>.
-  spirv::SpecConstantCompositeOp getSpecConstantComposite(uint32_t id) {
-    return specConstCompositeMap.lookup(id);
-  }
-
-  /// Creates a spirv::SpecConstantOp.
-  spirv::SpecConstantOp createSpecConstant(Location loc, uint32_t resultID,
-                                           Attribute defaultValue);
-
-  /// Processes the OpVariable instructions at current `offset` into `binary`.
-  /// It is expected that this method is used for variables that are to be
-  /// defined at module scope and will be deserialized into a spv.globalVariable
-  /// instruction.
-  LogicalResult processGlobalVariable(ArrayRef<uint32_t> operands);
-
-  /// Gets the global variable associated with a result <id> of OpVariable.
-  spirv::GlobalVariableOp getGlobalVariable(uint32_t id) {
-    return globalVariableMap.lookup(id);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Type
-  //===--------------------------------------------------------------------===//
-
-  /// Gets type for a given result <id>.
-  Type getType(uint32_t id) { return typeMap.lookup(id); }
-
-  /// Get the type associated with the result <id> of an OpUndef.
-  Type getUndefType(uint32_t id) { return undefMap.lookup(id); }
-
-  /// Returns true if the given `type` is for SPIR-V void type.
-  bool isVoidType(Type type) const { return type.isa<NoneType>(); }
-
-  /// Processes a SPIR-V type instruction with given `opcode` and `operands` and
-  /// registers the type into `module`.
-  LogicalResult processType(spirv::Opcode opcode, ArrayRef<uint32_t> operands);
-
-  LogicalResult processOpTypePointer(ArrayRef<uint32_t> operands);
-
-  LogicalResult processArrayType(ArrayRef<uint32_t> operands);
-
-  LogicalResult processCooperativeMatrixType(ArrayRef<uint32_t> operands);
-
-  LogicalResult processFunctionType(ArrayRef<uint32_t> operands);
-
-  LogicalResult processRuntimeArrayType(ArrayRef<uint32_t> operands);
-
-  LogicalResult processStructType(ArrayRef<uint32_t> operands);
-
-  LogicalResult processMatrixType(ArrayRef<uint32_t> operands);
-
-  //===--------------------------------------------------------------------===//
-  // Constant
-  //===--------------------------------------------------------------------===//
-
-  /// Processes a SPIR-V Op{|Spec}Constant instruction with the given
-  /// `operands`. `isSpec` indicates whether this is a specialization constant.
-  LogicalResult processConstant(ArrayRef<uint32_t> operands, bool isSpec);
-
-  /// Processes a SPIR-V Op{|Spec}Constant{True|False} instruction with the
-  /// given `operands`. `isSpec` indicates whether this is a specialization
-  /// constant.
-  LogicalResult processConstantBool(bool isTrue, ArrayRef<uint32_t> operands,
-                                    bool isSpec);
-
-  /// Processes a SPIR-V OpConstantComposite instruction with the given
-  /// `operands`.
-  LogicalResult processConstantComposite(ArrayRef<uint32_t> operands);
-
-  LogicalResult processSpecConstantComposite(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpConstantNull instruction with the given `operands`.
-  LogicalResult processConstantNull(ArrayRef<uint32_t> operands);
-
-  //===--------------------------------------------------------------------===//
-  // Debug
-  //===--------------------------------------------------------------------===//
-
-  /// Discontinues any source-level location information that might be active
-  /// from a previous OpLine instruction.
-  LogicalResult clearDebugLine();
-
-  /// Creates a FileLineColLoc with the OpLine location information.
-  Location createFileLineColLoc(OpBuilder opBuilder);
-
-  /// Processes a SPIR-V OpLine instruction with the given `operands`.
-  LogicalResult processDebugLine(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpString instruction with the given `operands`.
-  LogicalResult processDebugString(ArrayRef<uint32_t> operands);
-
-  //===--------------------------------------------------------------------===//
-  // Control flow
-  //===--------------------------------------------------------------------===//
-
-  /// Returns the block for the given label <id>.
-  Block *getBlock(uint32_t id) const { return blockMap.lookup(id); }
-
-  // In SPIR-V, structured control flow is explicitly declared using merge
-  // instructions (OpSelectionMerge and OpLoopMerge). In the SPIR-V dialect,
-  // we use spv.selection and spv.loop to group structured control flow.
-  // The deserializer need to turn structured control flow marked with merge
-  // instructions into using spv.selection/spv.loop ops.
-  //
-  // Because structured control flow can nest and the basic block order have
-  // flexibility, we cannot isolate a structured selection/loop without
-  // deserializing all the blocks. So we use the following approach:
-  //
-  // 1. Deserialize all basic blocks in a function and create MLIR blocks for
-  //    them into the function's region. In the meanwhile, keep a map between
-  //    selection/loop header blocks to their corresponding merge (and continue)
-  //    target blocks.
-  // 2. For each selection/loop header block, recursively get all basic blocks
-  //    reachable (except the merge block) and put them in a newly created
-  //    spv.selection/spv.loop's region. Structured control flow guarantees
-  //    that we enter and exit in structured ways and the construct is nestable.
-  // 3. Put the new spv.selection/spv.loop op at the beginning of the old merge
-  //    block and redirect all branches to the old header block to the old
-  //    merge block (which contains the spv.selection/spv.loop op now).
-
-  /// For OpPhi instructions, we use block arguments to represent them. OpPhi
-  /// encodes a list of (value, predecessor) pairs. At the time of handling the
-  /// block containing an OpPhi instruction, the predecessor block might not be
-  /// processed yet, also the value sent by it. So we need to defer handling
-  /// the block argument from the predecessors. We use the following approach:
-  ///
-  /// 1. For each OpPhi instruction, add a block argument to the current block
-  ///    in construction. Record the block argument in `valueMap` so its uses
-  ///    can be resolved. For the list of (value, predecessor) pairs, update
-  ///    `blockPhiInfo` for bookkeeping.
-  /// 2. After processing all blocks, loop over `blockPhiInfo` to fix up each
-  ///    block recorded there to create the proper block arguments on their
-  ///    terminators.
-
-  /// A data structure for containing a SPIR-V block's phi info. It will be
-  /// represented as block argument in SPIR-V dialect.
-  using BlockPhiInfo =
-      SmallVector<uint32_t, 2>; // The result <id> of the values sent
-
-  /// Gets or creates the block corresponding to the given label <id>. The newly
-  /// created block will always be placed at the end of the current function.
-  Block *getOrCreateBlock(uint32_t id);
-
-  LogicalResult processBranch(ArrayRef<uint32_t> operands);
-
-  LogicalResult processBranchConditional(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpLabel instruction with the given `operands`.
-  LogicalResult processLabel(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpSelectionMerge instruction with the given `operands`.
-  LogicalResult processSelectionMerge(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpLoopMerge instruction with the given `operands`.
-  LogicalResult processLoopMerge(ArrayRef<uint32_t> operands);
-
-  /// Processes a SPIR-V OpPhi instruction with the given `operands`.
-  LogicalResult processPhi(ArrayRef<uint32_t> operands);
-
-  /// Creates block arguments on predecessors previously recorded when handling
-  /// OpPhi instructions.
-  LogicalResult wireUpBlockArgument();
-
-  /// Extracts blocks belonging to a structured selection/loop into a
-  /// spv.selection/spv.loop op. This method iterates until all blocks
-  /// declared as selection/loop headers are handled.
-  LogicalResult structurizeControlFlow();
-
-  //===--------------------------------------------------------------------===//
-  // Instruction
-  //===--------------------------------------------------------------------===//
-
-  /// Get the Value associated with a result <id>.
-  ///
-  /// This method materializes normal constants and inserts "casting" ops
-  /// (`spv.mlir.addressof` and `spv.mlir.referenceof`) to turn an symbol into a
-  /// SSA value for handling uses of module scope constants/variables in
-  /// functions.
-  Value getValue(uint32_t id);
-
-  /// Slices the first instruction out of `binary` and returns its opcode and
-  /// operands via `opcode` and `operands` respectively. Returns failure if
-  /// there is no more remaining instructions (`expectedOpcode` will be used to
-  /// compose the error message) or the next instruction is malformed.
-  LogicalResult
-  sliceInstruction(spirv::Opcode &opcode, ArrayRef<uint32_t> &operands,
-                   Optional<spirv::Opcode> expectedOpcode = llvm::None);
-
-  /// Processes a SPIR-V instruction with the given `opcode` and `operands`.
-  /// This method is the main entrance for handling SPIR-V instruction; it
-  /// checks the instruction opcode and dispatches to the corresponding handler.
-  /// Processing of Some instructions (like OpEntryPoint and OpExecutionMode)
-  /// might need to be deferred, since they contain forward references to <id>s
-  /// in the deserialized binary, but module in SPIR-V dialect expects these to
-  /// be ssa-uses.
-  LogicalResult processInstruction(spirv::Opcode opcode,
-                                   ArrayRef<uint32_t> operands,
-                                   bool deferInstructions = true);
-
-  /// Processes a SPIR-V instruction from the given `operands`. It should
-  /// deserialize into an op with the given `opName` and `numOperands`.
-  /// This method is a generic one for dispatching any SPIR-V ops without
-  /// variadic operands and attributes in TableGen definitions.
-  LogicalResult processOpWithoutGrammarAttr(ArrayRef<uint32_t> words,
-                                            StringRef opName, bool hasResult,
-                                            unsigned numOperands);
-
-  /// Processes a OpUndef instruction. Adds a spv.Undef operation at the current
-  /// insertion point.
-  LogicalResult processUndef(ArrayRef<uint32_t> operands);
-
-  LogicalResult processTypeForwardPointer(ArrayRef<uint32_t> operands);
-
-  /// Method to dispatch to the specialized deserialization function for an
-  /// operation in SPIR-V dialect that is a mirror of an instruction in the
-  /// SPIR-V spec. This is auto-generated from ODS. Dispatch is handled for
-  /// all operations in SPIR-V dialect that have hasOpcode == 1.
-  LogicalResult dispatchToAutogenDeserialization(spirv::Opcode opcode,
-                                                 ArrayRef<uint32_t> words);
-
-  /// Processes a SPIR-V OpExtInst with given `operands`. This slices the
-  /// entries of `operands` that specify the extended instruction set <id> and
-  /// the instruction opcode. The op deserializer is then invoked using the
-  /// other entries.
-  LogicalResult processExtInst(ArrayRef<uint32_t> operands);
-
-  /// Dispatches the deserialization of extended instruction set operation based
-  /// on the extended instruction set name, and instruction opcode. This is
-  /// autogenerated from ODS.
-  LogicalResult
-  dispatchToExtensionSetAutogenDeserialization(StringRef extensionSetName,
-                                               uint32_t instructionID,
-                                               ArrayRef<uint32_t> words);
-
-  /// Method to deserialize an operation in the SPIR-V dialect that is a mirror
-  /// of an instruction in the SPIR-V spec. This is auto generated if hasOpcode
-  /// == 1 and autogenSerialization == 1 in ODS.
-  template <typename OpTy>
-  LogicalResult processOp(ArrayRef<uint32_t> words) {
-    return emitError(unknownLoc, "unsupported deserialization for ")
-           << OpTy::getOperationName() << " op";
-  }
-
-private:
-  /// The SPIR-V binary module.
-  ArrayRef<uint32_t> binary;
-
-  /// Contains the data of the OpLine instruction which precedes the current
-  /// processing instruction.
-  llvm::Optional<DebugLine> debugLine;
-
-  /// The current word offset into the binary module.
-  unsigned curOffset = 0;
-
-  /// MLIRContext to create SPIR-V ModuleOp into.
-  MLIRContext *context;
-
-  // TODO: create Location subclass for binary blob
-  Location unknownLoc;
-
-  /// The SPIR-V ModuleOp.
-  spirv::OwningSPIRVModuleRef module;
-
-  /// The current function under construction.
-  Optional<spirv::FuncOp> curFunction;
-
-  /// The current block under construction.
-  Block *curBlock = nullptr;
-
-  OpBuilder opBuilder;
-
-  spirv::Version version;
-
-  /// The list of capabilities used by the module.
-  llvm::SmallSetVector<spirv::Capability, 4> capabilities;
-
-  /// The list of extensions used by the module.
-  llvm::SmallSetVector<spirv::Extension, 2> extensions;
-
-  // Result <id> to type mapping.
-  DenseMap<uint32_t, Type> typeMap;
-
-  // Result <id> to constant attribute and type mapping.
-  ///
-  /// In the SPIR-V binary format, all constants are placed in the module and
-  /// shared by instructions at module level and in subsequent functions. But in
-  /// the SPIR-V dialect, we materialize the constant to where it's used in the
-  /// function. So when seeing a constant instruction in the binary format, we
-  /// don't immediately emit a constant op into the module, we keep its value
-  /// (and type) here. Later when it's used, we materialize the constant.
-  DenseMap<uint32_t, std::pair<Attribute, Type>> constantMap;
-
-  // Result <id> to spec constant mapping.
-  DenseMap<uint32_t, spirv::SpecConstantOp> specConstMap;
-
-  // Result <id> to composite spec constant mapping.
-  DenseMap<uint32_t, spirv::SpecConstantCompositeOp> specConstCompositeMap;
-
-  // Result <id> to variable mapping.
-  DenseMap<uint32_t, spirv::GlobalVariableOp> globalVariableMap;
-
-  // Result <id> to function mapping.
-  DenseMap<uint32_t, spirv::FuncOp> funcMap;
-
-  // Result <id> to block mapping.
-  DenseMap<uint32_t, Block *> blockMap;
-
-  // Header block to its merge (and continue) target mapping.
-  BlockMergeInfoMap blockMergeInfo;
-
-  // Block to its phi (block argument) mapping.
-  DenseMap<Block *, BlockPhiInfo> blockPhiInfo;
-
-  // Result <id> to value mapping.
-  DenseMap<uint32_t, Value> valueMap;
-
-  // Mapping from result <id> to undef value of a type.
-  DenseMap<uint32_t, Type> undefMap;
-
-  // Result <id> to name mapping.
-  DenseMap<uint32_t, StringRef> nameMap;
-
-  // Result <id> to debug info mapping.
-  DenseMap<uint32_t, StringRef> debugInfoMap;
-
-  // Result <id> to decorations mapping.
-  DenseMap<uint32_t, NamedAttrList> decorations;
-
-  // Result <id> to type decorations.
-  DenseMap<uint32_t, uint32_t> typeDecorations;
-
-  // Result <id> to member decorations.
-  // decorated-struct-type-<id> ->
-  //    (struct-member-index -> (decoration -> decoration-operands))
-  DenseMap<uint32_t,
-           DenseMap<uint32_t, DenseMap<spirv::Decoration, ArrayRef<uint32_t>>>>
-      memberDecorationMap;
-
-  // Result <id> to member name.
-  // struct-type-<id> -> (struct-member-index -> name)
-  DenseMap<uint32_t, DenseMap<uint32_t, StringRef>> memberNameMap;
-
-  // Result <id> to extended instruction set name.
-  DenseMap<uint32_t, StringRef> extendedInstSets;
-
-  // List of instructions that are processed in a deferred fashion (after an
-  // initial processing of the entire binary). Some operations like
-  // OpEntryPoint, and OpExecutionMode use forward references to function
-  // <id>s. In SPIR-V dialect the corresponding operations (spv.EntryPoint and
-  // spv.ExecutionMode) need these references resolved. So these instructions
-  // are deserialized and stored for processing once the entire binary is
-  // processed.
-  SmallVector<std::pair<spirv::Opcode, ArrayRef<uint32_t>>, 4>
-      deferredInstructions;
-
-  /// A list of IDs for all types forward-declared through OpTypeForwardPointer
-  /// instructions.
-  llvm::SetVector<uint32_t> typeForwardPointerIDs;
-
-  /// A list of all structs which have unresolved member types.
-  SmallVector<DeferredStructTypeInfo, 0> deferredStructTypesInfos;
-};
-} // namespace
-
 //===----------------------------------------------------------------------===//
 // Deserializer Method Definitions
 //===----------------------------------------------------------------------===//
 
-Deserializer::Deserializer(ArrayRef<uint32_t> binary, MLIRContext *context)
+spirv::Deserializer::Deserializer(ArrayRef<uint32_t> binary,
+                                  MLIRContext *context)
     : binary(binary), context(context), unknownLoc(UnknownLoc::get(context)),
       module(createModuleOp()), opBuilder(module->body()) {}
 
-LogicalResult Deserializer::deserialize() {
+LogicalResult spirv::Deserializer::deserialize() {
   LLVM_DEBUG(llvm::dbgs() << "+++ starting deserialization +++\n");
 
   if (failed(processHeader()))
     return failure();
 
   spirv::Opcode opcode = spirv::Opcode::OpNop;
   ArrayRef<uint32_t> operands;
   auto binarySize = binary.size();
LogicalResult spirv::Deserializer::deserialize() {
   }
 
   attachVCETriple();
 
   LLVM_DEBUG(llvm::dbgs() << "+++ completed deserialization +++\n");
   return success();
 }
 
-spirv::OwningSPIRVModuleRef Deserializer::collect() {
+spirv::OwningSPIRVModuleRef spirv::Deserializer::collect() {
   return std::move(module);
 }
 
 //===----------------------------------------------------------------------===//
 // Module structure
 //===----------------------------------------------------------------------===//
 
-spirv::OwningSPIRVModuleRef Deserializer::createModuleOp() {
+spirv::OwningSPIRVModuleRef spirv::Deserializer::createModuleOp() {
   OpBuilder builder(context);
   OperationState state(unknownLoc, spirv::ModuleOp::getOperationName());
   spirv::ModuleOp::build(builder, state);
   return cast<spirv::ModuleOp>(Operation::create(state));
 }
 
-LogicalResult Deserializer::processHeader() {
+LogicalResult spirv::Deserializer::processHeader() {
   if (binary.size() < spirv::kHeaderWordCount)
     return emitError(unknownLoc,
                      "SPIR-V binary module must have a 5-word header");
 
   if (binary[0] != spirv::kMagicNumber)
     return emitError(unknownLoc, "incorrect magic number");
 
   // Version number bytes: 0 | major number | minor number | 0
return emitError(unknownLoc, "unsupported SPIR-V major version: ")
            << majorVersion;
   }
 
   // TODO: generator number, bound, schema
   curOffset = spirv::kHeaderWordCount;
   return success();
 }
 
-LogicalResult Deserializer::processCapability(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processCapability(ArrayRef<uint32_t> operands) {
   if (operands.size() != 1)
     return emitError(unknownLoc, "OpMemoryModel must have one parameter");
 
   auto cap = spirv::symbolizeCapability(operands[0]);
   if (!cap)
     return emitError(unknownLoc, "unknown capability: ") << operands[0];
 
   capabilities.insert(*cap);
   return success();
 }
 
-LogicalResult Deserializer::processExtension(ArrayRef<uint32_t> words) {
+LogicalResult spirv::Deserializer::processExtension(ArrayRef<uint32_t> words) {
   if (words.empty()) {
     return emitError(
         unknownLoc,
         "OpExtension must have a literal string for the extension name");
   }
 
   unsigned wordIndex = 0;
   StringRef extName = decodeStringLiteral(words, wordIndex);
   if (wordIndex != words.size())
     return emitError(unknownLoc,
                      "unexpected trailing words in OpExtension instruction");
   auto ext = spirv::symbolizeExtension(extName);
   if (!ext)
     return emitError(unknownLoc, "unknown extension: ") << extName;
 
   extensions.insert(*ext);
   return success();
 }
 
-LogicalResult Deserializer::processExtInstImport(ArrayRef<uint32_t> words) {
+LogicalResult
+spirv::Deserializer::processExtInstImport(ArrayRef<uint32_t> words) {
   if (words.size() < 2) {
     return emitError(unknownLoc,
                      "OpExtInstImport must have a result <id> and a literal "
                      "string for the extended instruction set name");
   }
 
   unsigned wordIndex = 1;
   extendedInstSets[words[0]] = decodeStringLiteral(words, wordIndex);
   if (wordIndex != words.size()) {
     return emitError(unknownLoc,
                      "unexpected trailing words in OpExtInstImport");
   }
   return success();
 }
 
-void Deserializer::attachVCETriple() {
+void spirv::Deserializer::attachVCETriple() {
   (*module)->setAttr(
       spirv::ModuleOp::getVCETripleAttrName(),
       spirv::VerCapExtAttr::get(version, capabilities.getArrayRef(),
                                 extensions.getArrayRef(), context));
 }
 
-LogicalResult Deserializer::processMemoryModel(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processMemoryModel(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2)
     return emitError(unknownLoc, "OpMemoryModel must have two operands");
 
   (*module)->setAttr(
       "addressing_model",
       opBuilder.getI32IntegerAttr(llvm::bit_cast<int32_t>(operands.front())));
   (*module)->setAttr(
       "memory_model",
       opBuilder.getI32IntegerAttr(llvm::bit_cast<int32_t>(operands.back())));
 
   return success();
 }
 
-LogicalResult Deserializer::processDecoration(ArrayRef<uint32_t> words) {
+LogicalResult spirv::Deserializer::processDecoration(ArrayRef<uint32_t> words) {
   // TODO: This function should also be auto-generated. For now, since only a
   // few decorations are processed/handled in a meaningful manner, going with a
   // manual implementation.
   if (words.size() < 2) {
     return emitError(
         unknownLoc, "OpDecorate must have at least result <id> and Decoration");
   }
   auto decorationName =
decorations[words[0]].set(
         symbol, opBuilder.getI32IntegerAttr(static_cast<int32_t>(words[2])));
     break;
   default:
     return emitError(unknownLoc, "unhandled Decoration : '") << decorationName;
   }
   return success();
 }
 
-LogicalResult Deserializer::processMemberDecoration(ArrayRef<uint32_t> words) {
+LogicalResult
+spirv::Deserializer::processMemberDecoration(ArrayRef<uint32_t> words) {
   // The binary layout of OpMemberDecorate is different comparing to OpDecorate
   if (words.size() < 3) {
     return emitError(unknownLoc,
                      "OpMemberDecorate must have at least 3 operands");
   }
 
   auto decoration = static_cast<spirv::Decoration>(words[2]);
   if (decoration == spirv::Decoration::Offset && words.size() != 4) {
     return emitError(unknownLoc,
                      " missing offset specification in OpMemberDecorate with "
                      "Offset decoration");
   }
   ArrayRef<uint32_t> decorationOperands;
   if (words.size() > 3) {
     decorationOperands = words.slice(3);
   }
   memberDecorationMap[words[0]][words[1]][decoration] = decorationOperands;
   return success();
 }
 
-LogicalResult Deserializer::processMemberName(ArrayRef<uint32_t> words) {
+LogicalResult spirv::Deserializer::processMemberName(ArrayRef<uint32_t> words) {
   if (words.size() < 3) {
     return emitError(unknownLoc, "OpMemberName must have at least 3 operands");
   }
   unsigned wordIndex = 2;
   auto name = decodeStringLiteral(words, wordIndex);
   if (wordIndex != words.size()) {
     return emitError(unknownLoc,
                      "unexpected trailing words in OpMemberName instruction");
   }
   memberNameMap[words[0]][words[1]] = name;
   return success();
 }
 
-LogicalResult Deserializer::processFunction(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processFunction(ArrayRef<uint32_t> operands) {
   if (curFunction) {
     return emitError(unknownLoc, "found function inside function");
   }
 
   // Get the result type
   if (operands.size() != 4) {
     return emitError(unknownLoc, "OpFunction must have 4 parameters");
   }
if (opcode != spirv::Opcode::OpFunctionEnd) {
     return failure();
   }
 
   LLVM_DEBUG(llvm::dbgs() << "-- completed function '" << fnName << "' (type = "
                           << fnType << ", id = " << operands[1] << ") --\n");
   return processFunctionEnd(instOperands);
 }
 
-LogicalResult Deserializer::processFunctionEnd(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processFunctionEnd(ArrayRef<uint32_t> operands) {
   // Process OpFunctionEnd.
   if (!operands.empty()) {
     return emitError(unknownLoc, "unexpected operands for OpFunctionEnd");
   }
 
   // Wire up block arguments from OpPhi instructions.
   // Put all structured control flow in spv.selection/spv.loop ops.
   if (failed(wireUpBlockArgument()) || failed(structurizeControlFlow())) {
     return failure();
   }
 
   curBlock = nullptr;
   curFunction = llvm::None;
 
   return success();
 }
 
-Optional<std::pair<Attribute, Type>> Deserializer::getConstant(uint32_t id) {
+Optional<std::pair<Attribute, Type>>
+spirv::Deserializer::getConstant(uint32_t id) {
   auto constIt = constantMap.find(id);
   if (constIt == constantMap.end())
     return llvm::None;
   return constIt->getSecond();
 }
 
-std::string Deserializer::getFunctionSymbol(uint32_t id) {
+std::string spirv::Deserializer::getFunctionSymbol(uint32_t id) {
   auto funcName = nameMap.lookup(id).str();
   if (funcName.empty()) {
     funcName = "spirv_fn_" + std::to_string(id);
   }
   return funcName;
 }
 
-std::string Deserializer::getSpecConstantSymbol(uint32_t id) {
+std::string spirv::Deserializer::getSpecConstantSymbol(uint32_t id) {
   auto constName = nameMap.lookup(id).str();
   if (constName.empty()) {
     constName = "spirv_spec_const_" + std::to_string(id);
   }
   return constName;
 }
 
-spirv::SpecConstantOp Deserializer::createSpecConstant(Location loc,
-                                                       uint32_t resultID,
-                                                       Attribute defaultValue) {
+spirv::SpecConstantOp
+spirv::Deserializer::createSpecConstant(Location loc, uint32_t resultID,
   auto symName = opBuilder.getStringAttr(getSpecConstantSymbol(resultID));
   auto op = opBuilder.create<spirv::SpecConstantOp>(unknownLoc, symName,
                                                     defaultValue);
   if (decorations.count(resultID)) {
     for (auto attr : decorations[resultID].getAttrs())
       op->setAttr(attr.first, attr.second);
   }
   specConstMap[resultID] = op;
   return op;
 }
 
-LogicalResult Deserializer::processGlobalVariable(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processGlobalVariable(ArrayRef<uint32_t> operands) {
   unsigned wordIndex = 0;
   if (operands.size() < 3) {
     return emitError(
         unknownLoc,
         "OpVariable needs at least 3 operands, type, <id> and storage class");
   }
 
   // Result Type.
if (decorations.count(variableID)) {
     for (auto attr : decorations[variableID].getAttrs()) {
       varOp->setAttr(attr.first, attr.second);
     }
   }
   globalVariableMap[variableID] = varOp;
   return success();
 }
 
-IntegerAttr Deserializer::getConstantInt(uint32_t id) {
+IntegerAttr spirv::Deserializer::getConstantInt(uint32_t id) {
   auto constInfo = getConstant(id);
   if (!constInfo) {
     return nullptr;
   }
   return constInfo->first.dyn_cast<IntegerAttr>();
 }
 
-LogicalResult Deserializer::processName(ArrayRef<uint32_t> operands) {
+LogicalResult spirv::Deserializer::processName(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2) {
     return emitError(unknownLoc, "OpName needs at least 2 operands");
   }
   if (!nameMap.lookup(operands[0]).empty()) {
     return emitError(unknownLoc, "duplicate name found for result <id> ")
            << operands[0];
   }
   unsigned wordIndex = 1;
   StringRef name = decodeStringLiteral(operands, wordIndex);
   if (wordIndex != operands.size()) {
     return emitError(unknownLoc,
                      "unexpected trailing words in OpName instruction");
   }
   nameMap[operands[0]] = name;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
-LogicalResult Deserializer::processType(spirv::Opcode opcode,
+LogicalResult spirv::Deserializer::processType(spirv::Opcode opcode,
                                                ArrayRef<uint32_t> operands) {
   if (operands.empty()) {
     return emitError(unknownLoc, "type instruction with opcode ")
            << spirv::stringifyOpcode(opcode) << " needs at least one <id>";
   }
 
   /// TODO: Types might be forward declared in some instructions and need to be
   /// handled appropriately.
   if (typeMap.count(operands[0])) {
LogicalResult spirv::Deserializer::processType(spirv::Opcode opcode,
   case spirv::Opcode::OpTypeMatrix:
     return processMatrixType(operands);
   default:
     return emitError(unknownLoc, "unhandled type instruction");
   }
   return success();
 }
 
-LogicalResult Deserializer::processOpTypePointer(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processOpTypePointer(ArrayRef<uint32_t> operands) {
   if (operands.size() != 3)
     return emitError(unknownLoc, "OpTypePointer must have two parameters");
 
   auto pointeeType = getType(operands[2]);
   if (!pointeeType)
     return emitError(unknownLoc, "unknown OpTypePointer pointee type <id> ")
            << operands[2];
 
for (auto *deferredStructIt = std::begin(deferredStructTypesInfos);
     } else {
       ++deferredStructIt;
     }
   }
 
   return success();
 }
 
-LogicalResult Deserializer::processArrayType(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processArrayType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 3) {
     return emitError(unknownLoc,
                      "OpTypeArray must have element type and count parameters");
   }
 
   Type elementTy = getType(operands[1]);
   if (!elementTy) {
     return emitError(unknownLoc, "OpTypeArray references undefined <id> ")
return emitError(unknownLoc, "OpTypeArray count must come from a "
                                  "scalar integer constant instruction");
   }
 
   typeMap[operands[0]] = spirv::ArrayType::get(
       elementTy, count, typeDecorations.lookup(operands[0]));
   return success();
 }
 
-LogicalResult Deserializer::processFunctionType(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processFunctionType(ArrayRef<uint32_t> operands) {
   assert(!operands.empty() && "No operands for processing function type");
   if (operands.size() == 1) {
     return emitError(unknownLoc, "missing return type for OpTypeFunction");
   }
   auto returnType = getType(operands[1]);
   if (!returnType) {
     return emitError(unknownLoc, "unknown return type in OpTypeFunction");
   }
spirv::Deserializer::processFunctionType(ArrayRef<uint32_t> operands) {
   if (!isVoidType(returnType)) {
     returnTypes = llvm::makeArrayRef(returnType);
   }
   typeMap[operands[0]] = FunctionType::get(context, argTypes, returnTypes);
   return success();
 }
 
 LogicalResult
-Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) {
+spirv::Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 5) {
     return emitError(unknownLoc, "OpTypeCooperativeMatrix must have element "
                                  "type and row x column parameters");
   }
 
   Type elementTy = getType(operands[1]);
   if (!elementTy) {
     return emitError(unknownLoc,
spirv::Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) {
   unsigned columns = getConstantInt(operands[4]).getInt();
 
   typeMap[operands[0]] = spirv::CooperativeMatrixNVType::get(
       elementTy, scope.getValue(), rows, columns);
   return success();
 }
 
 LogicalResult
-Deserializer::processRuntimeArrayType(ArrayRef<uint32_t> operands) {
+spirv::Deserializer::processRuntimeArrayType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2) {
     return emitError(unknownLoc, "OpTypeRuntimeArray must have two operands");
   }
   Type memberType = getType(operands[1]);
   if (!memberType) {
     return emitError(unknownLoc,
                      "OpTypeRuntimeArray references undefined <id> ")
            << operands[1];
   }
   typeMap[operands[0]] = spirv::RuntimeArrayType::get(
       memberType, typeDecorations.lookup(operands[0]));
   return success();
 }
 
-LogicalResult Deserializer::processStructType(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processStructType(ArrayRef<uint32_t> operands) {
   // TODO: Find a way to handle identified structs when debug info is stripped.
 
   if (operands.empty()) {
     return emitError(unknownLoc, "OpTypeStruct must have at least result <id>");
   }
 
   if (operands.size() == 1) {
     // Handle empty struct.
else if (failed(structTy.trySetBody(memberTypes, offsetInfo,
       return failure();
   }
 
   // TODO: Update StructType to have member name as attribute as
   // well.
   return success();
 }
 
-LogicalResult Deserializer::processMatrixType(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processMatrixType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 3) {
     // Three operands are needed: result_id, column_type, and column_count
     return emitError(unknownLoc, "OpTypeMatrix must have 3 operands"
                                  " (result_id, column_type, and column_count)");
   }
   // Matrix columns must be of vector type
   Type elementTy = getType(operands[1]);
   if (!elementTy) {
     return emitError(unknownLoc,
                      "OpTypeMatrix references undefined column type.")
            << operands[1];
   }
 
   uint32_t colsCount = operands[2];
   typeMap[operands[0]] = spirv::MatrixType::get(elementTy, colsCount);
   return success();
 }
 
+LogicalResult
+spirv::Deserializer::processTypeForwardPointer(ArrayRef<uint32_t> operands) {
+  if (operands.size() != 2)
+    return emitError(unknownLoc,
+                     "OpTypeForwardPointer instruction must have two operands");
+
+  typeForwardPointerIDs.insert(operands[0]);
+  // TODO: Use the 2nd operand (Storage Class) to validate the OpTypePointer
+  // instruction that defines the actual type.
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Constant
 //===----------------------------------------------------------------------===//
 
-LogicalResult Deserializer::processConstant(ArrayRef<uint32_t> operands,
+LogicalResult spirv::Deserializer::processConstant(ArrayRef<uint32_t> operands,
                                                    bool isSpec) {
   StringRef opname = isSpec ? "OpSpecConstant" : "OpConstant";
 
   if (operands.size() < 2) {
     return emitError(unknownLoc)
            << opname << " must have type <id> and result <id>";
   }
   if (operands.size() < 3) {
     return emitError(unknownLoc)
if (auto floatType = resultType.dyn_cast<FloatType>()) {
 
     return success();
   }
 
   return emitError(unknownLoc, "OpConstant can only generate values of "
                                "scalar integer or floating-point type");
 }
 
-LogicalResult Deserializer::processConstantBool(bool isTrue,
-                                                ArrayRef<uint32_t> operands,
-                                                bool isSpec) {
+LogicalResult spirv::Deserializer::processConstantBool(
+    bool isTrue, ArrayRef<uint32_t> operands, bool isSpec) {
   if (operands.size() != 2) {
     return emitError(unknownLoc, "Op")
            << (isSpec ? "Spec" : "") << "Constant"
            << (isTrue ? "True" : "False")
            << " must have type <id> and result <id>";
   }
 
   auto attr = opBuilder.getBoolAttr(isTrue);
   auto resultID = operands[1];
   if (isSpec) {
     createSpecConstant(unknownLoc, resultID, attr);
   } else {
     // For normal constants, we just record the attribute (and its type) for
     // later materialization at use sites.
     constantMap.try_emplace(resultID, attr, opBuilder.getI1Type());
   }
 
   return success();
 }
 
 LogicalResult
-Deserializer::processConstantComposite(ArrayRef<uint32_t> operands) {
+spirv::Deserializer::processConstantComposite(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2) {
     return emitError(unknownLoc,
                      "OpConstantComposite must have type <id> and result <id>");
   }
   if (operands.size() < 3) {
     return emitError(unknownLoc,
                      "OpConstantComposite must have at least 1 parameter");
   }
if (auto vectorType = resultType.dyn_cast<VectorType>()) {
     return emitError(unknownLoc, "unsupported OpConstantComposite type: ")
            << resultType;
   }
 
   return success();
 }
 
 LogicalResult
-Deserializer::processSpecConstantComposite(ArrayRef<uint32_t> operands) {
+spirv::Deserializer::processSpecConstantComposite(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2) {
     return emitError(unknownLoc,
                      "OpConstantComposite must have type <id> and result <id>");
   }
   if (operands.size() < 3) {
     return emitError(unknownLoc,
                      "OpConstantComposite must have at least 1 parameter");
   }
spirv::Deserializer::processSpecConstantComposite(ArrayRef<uint32_t> operands) {
   auto op = opBuilder.create<spirv::SpecConstantCompositeOp>(
       unknownLoc, TypeAttr::get(resultType), symName,
       opBuilder.getArrayAttr(elements));
   specConstCompositeMap[resultID] = op;
 
   return success();
 }
 
-LogicalResult Deserializer::processConstantNull(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processConstantNull(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2) {
     return emitError(unknownLoc,
                      "OpConstantNull must have type <id> and result <id>");
   }
 
   Type resultType = getType(operands[0]);
   if (!resultType) {
     return emitError(unknownLoc, "undefined result type from <id> ")
spirv::Deserializer::processConstantNull(ArrayRef<uint32_t> operands) {
   return emitError(unknownLoc, "unsupported OpConstantNull type: ")
          << resultType;
 }
 
 //===----------------------------------------------------------------------===//
 // Control flow
 //===----------------------------------------------------------------------===//
 
-Block *Deserializer::getOrCreateBlock(uint32_t id) {
+Block *spirv::Deserializer::getOrCreateBlock(uint32_t id) {
   if (auto *block = getBlock(id)) {
     LLVM_DEBUG(llvm::dbgs() << "[block] got exiting block for id = " << id
                             << " @ " << block << "\n");
     return block;
   }
 
   // We don't know where this block will be placed finally (in a spv.selection
   // or spv.loop or function). Create it into the function for now and sort
   // out the proper place later.
   auto *block = curFunction->addBlock();
   LLVM_DEBUG(llvm::dbgs() << "[block] created block for id = " << id << " @ "
                           << block << "\n");
   return blockMap[id] = block;
 }
 
-LogicalResult Deserializer::processBranch(ArrayRef<uint32_t> operands) {
+LogicalResult spirv::Deserializer::processBranch(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc, "OpBranch must appear inside a block");
   }
 
   if (operands.size() != 1) {
     return emitError(unknownLoc, "OpBranch must take exactly one target label");
   }
 
   auto *target = getOrCreateBlock(operands[0]);
   auto loc = createFileLineColLoc(opBuilder);
   // The preceding instruction for the OpBranch instruction could be an
   // OpLoopMerge or an OpSelectionMerge instruction, in this case they will have
   // the same OpLine information.
   opBuilder.create<spirv::BranchOp>(loc, target);
 
   clearDebugLine();
   return success();
 }
 
 LogicalResult
-Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
+spirv::Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc,
                      "OpBranchConditional must appear inside a block");
   }
 
   if (operands.size() != 3 && operands.size() != 5) {
     return emitError(unknownLoc,
                      "OpBranchConditional must have condition, true label, "
opBuilder.create<spirv::BranchConditionalOp>(
       loc, condition, trueBlock,
       /*trueArguments=*/ArrayRef<Value>(), falseBlock,
       /*falseArguments=*/ArrayRef<Value>(), weights);
 
   clearDebugLine();
   return success();
 }
 
-LogicalResult Deserializer::processLabel(ArrayRef<uint32_t> operands) {
+LogicalResult spirv::Deserializer::processLabel(ArrayRef<uint32_t> operands) {
   if (!curFunction) {
     return emitError(unknownLoc, "OpLabel must appear inside a function");
   }
 
   if (operands.size() != 1) {
     return emitError(unknownLoc, "OpLabel should only have result <id>");
   }
 
   auto labelID = operands[0];
   // We may have forward declared this block.
   auto *block = getOrCreateBlock(labelID);
   LLVM_DEBUG(llvm::dbgs() << "[block] populating block " << block << "\n");
   // If we have seen this block, make sure it was just a forward declaration.
   assert(block->empty() && "re-deserialize the same block!");
 
   opBuilder.setInsertionPointToStart(block);
   blockMap[labelID] = curBlock = block;
 
   return success();
 }
 
-LogicalResult Deserializer::processSelectionMerge(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processSelectionMerge(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc, "OpSelectionMerge must appear in a block");
   }
 
   if (operands.size() < 2) {
     return emitError(
         unknownLoc,
         "OpSelectionMerge must specify merge target and selection control");
   }
 
   auto *mergeBlock = getOrCreateBlock(operands[0]);
   auto loc = createFileLineColLoc(opBuilder);
   auto selectionControl = operands[1];
 
   if (!blockMergeInfo.try_emplace(curBlock, loc, selectionControl, mergeBlock)
            .second) {
     return emitError(
         unknownLoc,
         "a block cannot have more than one OpSelectionMerge instruction");
   }
 
   return success();
 }
 
-LogicalResult Deserializer::processLoopMerge(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processLoopMerge(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc, "OpLoopMerge must appear in a block");
   }
 
   if (operands.size() < 3) {
     return emitError(unknownLoc, "OpLoopMerge must specify merge target, "
                                  "continue target and loop control");
   }
if (!blockMergeInfo
     return emitError(
         unknownLoc,
         "a block cannot have more than one OpLoopMerge instruction");
   }
 
   return success();
 }
 
-LogicalResult Deserializer::processPhi(ArrayRef<uint32_t> operands) {
+LogicalResult spirv::Deserializer::processPhi(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc, "OpPhi must appear in a block");
   }
 
   if (operands.size() < 4) {
     return emitError(unknownLoc, "OpPhi must specify result type, result <id>, "
                                  "and variable-parent pairs");
   }
public:
   /// Structurizes the loop at the given `headerBlock`.
   ///
   /// This method will create an spv.loop op in the `mergeBlock` and move all
   /// blocks in the structured loop into the spv.loop's region. All branches to
   /// the `headerBlock` will be redirected to the `mergeBlock`.
   /// This method will also update `mergeInfo` by remapping all blocks inside to
   /// the newly cloned ones inside structured control flow op's regions.
   static LogicalResult structurize(Location loc, uint32_t control,
-                                   BlockMergeInfoMap &mergeInfo,
+                                   spirv::BlockMergeInfoMap &mergeInfo,
                                    Block *headerBlock, Block *mergeBlock,
                                    Block *continueBlock) {
     return ControlFlowStructurizer(loc, control, mergeInfo, headerBlock,
                                    mergeBlock, continueBlock)
         .structurizeImpl();
   }
 
 private:
   ControlFlowStructurizer(Location loc, uint32_t control,
-                          BlockMergeInfoMap &mergeInfo, Block *header,
+                          spirv::BlockMergeInfoMap &mergeInfo, Block *header,
                           Block *merge, Block *cont)
       : location(loc), control(control), blockMergeInfo(mergeInfo),
         headerBlock(header), mergeBlock(merge), continueBlock(cont) {}
 
   /// Creates a new spv.selection op at the beginning of the `mergeBlock`.
   spirv::SelectionOp createSelectionOp(uint32_t selectionControl);
 
   /// Creates a new spv.loop op at the beginning of the `mergeBlock`.
   spirv::LoopOp createLoopOp(uint32_t loopControl);
 
   /// Collects all blocks reachable from `headerBlock` except `mergeBlock`.
   void collectBlocksInConstruct();
 
   LogicalResult structurizeImpl();
 
   Location location;
   uint32_t control;
 
-  BlockMergeInfoMap &blockMergeInfo;
+  spirv::BlockMergeInfoMap &blockMergeInfo;
 
   Block *headerBlock;
   Block *mergeBlock;
   Block *continueBlock; // nullptr for spv.selection
 
   llvm::SetVector<Block *> constructBlocks;
 };
 } // namespace
LogicalResult ControlFlowStructurizer::structurizeImpl() {
   LLVM_DEBUG(
       llvm::dbgs() << "[cf] after structurizing construct with header block "
                    << headerBlock << ":\n"
                    << *op << '\n');
 
   return success();
 }
 
-LogicalResult Deserializer::wireUpBlockArgument() {
+LogicalResult spirv::Deserializer::wireUpBlockArgument() {
   LLVM_DEBUG(llvm::dbgs() << "[phi] start wiring up block arguments\n");
 
   OpBuilder::InsertionGuard guard(opBuilder);
 
   for (const auto &info : blockPhiInfo) {
     Block *block = info.first;
     const BlockPhiInfo &phiInfo = info.second;
     LLVM_DEBUG(llvm::dbgs() << "[phi] block " << block << "\n");
for (const auto &info : blockPhiInfo) {
     LLVM_DEBUG(llvm::dbgs() << '\n');
   }
   blockPhiInfo.clear();
 
   LLVM_DEBUG(llvm::dbgs() << "[phi] completed wiring up block arguments\n");
   return success();
 }
 
-LogicalResult Deserializer::structurizeControlFlow() {
+LogicalResult spirv::Deserializer::structurizeControlFlow() {
   LLVM_DEBUG(llvm::dbgs() << "[cf] start structurizing control flow\n");
 
   while (!blockMergeInfo.empty()) {
     Block *headerBlock = blockMergeInfo.begin()->first;
     BlockMergeInfo mergeInfo = blockMergeInfo.begin()->second;
 
     LLVM_DEBUG(llvm::dbgs() << "[cf] header block " << headerBlock << ":\n");
     LLVM_DEBUG(headerBlock->print(llvm::dbgs()));
LogicalResult spirv::Deserializer::structurizeControlFlow() {
   LLVM_DEBUG(llvm::dbgs() << "[cf] completed structurizing control flow\n");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Debug
 //===----------------------------------------------------------------------===//
 
-Location Deserializer::createFileLineColLoc(OpBuilder opBuilder) {
+Location spirv::Deserializer::createFileLineColLoc(OpBuilder opBuilder) {
   if (!debugLine)
     return unknownLoc;
 
   auto fileName = debugInfoMap.lookup(debugLine->fileID).str();
   if (fileName.empty())
     fileName = "<unknown>";
   return opBuilder.getFileLineColLoc(opBuilder.getIdentifier(fileName),
                                      debugLine->line, debugLine->col);
 }
 
-LogicalResult Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
   // According to SPIR-V spec:
   // "This location information applies to the instructions physically
   // following this instruction, up to the first occurrence of any of the
   // following: the next end of block, the next OpLine instruction, or the next
   // OpNoLine instruction."
   if (operands.size() != 3)
     return emitError(unknownLoc, "OpLine must have 3 operands");
   debugLine = DebugLine(operands[0], operands[1], operands[2]);
   return success();
 }
 
-LogicalResult Deserializer::clearDebugLine() {
+LogicalResult spirv::Deserializer::clearDebugLine() {
   debugLine = llvm::None;
   return success();
 }
 
-LogicalResult Deserializer::processDebugString(ArrayRef<uint32_t> operands) {
+LogicalResult
+spirv::Deserializer::processDebugString(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2)
     return emitError(unknownLoc, "OpString needs at least 2 operands");
 
   if (!debugInfoMap.lookup(operands[0]).empty())
     return emitError(unknownLoc,
                      "duplicate debug string found for result <id> ")
            << operands[0];
 
   unsigned wordIndex = 1;
   StringRef debugString = decodeStringLiteral(operands, wordIndex);
   if (wordIndex != operands.size())
     return emitError(unknownLoc,
                      "unexpected trailing words in OpString instruction");
 
   debugInfoMap[operands[0]] = debugString;
   return success();
 }
-
-//===----------------------------------------------------------------------===//
-// Instruction
-//===----------------------------------------------------------------------===//
-
-Value Deserializer::getValue(uint32_t id) {
-  if (auto constInfo = getConstant(id)) {
-    // Materialize a `spv.constant` op at every use site.
-    return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second,
-                                               constInfo->first);
-  }
-  if (auto varOp = getGlobalVariable(id)) {
-    auto addressOfOp = opBuilder.create<spirv::AddressOfOp>(
-        unknownLoc, varOp.type(),
-        opBuilder.getSymbolRefAttr(varOp.getOperation()));
-    return addressOfOp.pointer();
-  }
-  if (auto constOp = getSpecConstant(id)) {
-    auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
-        unknownLoc, constOp.default_value().getType(),
-        opBuilder.getSymbolRefAttr(constOp.getOperation()));
-    return referenceOfOp.reference();
-  }
-  if (auto constCompositeOp = getSpecConstantComposite(id)) {
-    auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
-        unknownLoc, constCompositeOp.type(),
-        opBuilder.getSymbolRefAttr(constCompositeOp.getOperation()));
-    return referenceOfOp.reference();
-  }
-  if (auto undef = getUndefType(id)) {
-    return opBuilder.create<spirv::UndefOp>(unknownLoc, undef);
-  }
-  return valueMap.lookup(id);
-}
-
-LogicalResult
-Deserializer::sliceInstruction(spirv::Opcode &opcode,
-                               ArrayRef<uint32_t> &operands,
-                               Optional<spirv::Opcode> expectedOpcode) {
-  auto binarySize = binary.size();
-  if (curOffset >= binarySize) {
-    return emitError(unknownLoc, "expected ")
-           << (expectedOpcode ? spirv::stringifyOpcode(*expectedOpcode)
-                              : "more")
-           << " instruction";
-  }
-
-  // For each instruction, get its word count from the first word to slice it
-  // from the stream properly, and then dispatch to the instruction handler.
-
-  uint32_t wordCount = binary[curOffset] >> 16;
-
-  if (wordCount == 0)
-    return emitError(unknownLoc, "word count cannot be zero");
-
-  uint32_t nextOffset = curOffset + wordCount;
-  if (nextOffset > binarySize)
-    return emitError(unknownLoc, "insufficient words for the last instruction");
-
-  opcode = extractOpcode(binary[curOffset]);
-  operands = binary.slice(curOffset + 1, wordCount - 1);
-  curOffset = nextOffset;
-  return success();
-}
-
-LogicalResult Deserializer::processInstruction(spirv::Opcode opcode,
-                                               ArrayRef<uint32_t> operands,
-                                               bool deferInstructions) {
-  LLVM_DEBUG(llvm::dbgs() << "[inst] processing instruction "
-                          << spirv::stringifyOpcode(opcode) << "\n");
-
-  // First dispatch all the instructions whose opcode does not correspond to
-  // those that have a direct mirror in the SPIR-V dialect
-  switch (opcode) {
-  case spirv::Opcode::OpCapability:
-    return processCapability(operands);
-  case spirv::Opcode::OpExtension:
-    return processExtension(operands);
-  case spirv::Opcode::OpExtInst:
-    return processExtInst(operands);
-  case spirv::Opcode::OpExtInstImport:
-    return processExtInstImport(operands);
-  case spirv::Opcode::OpMemberName:
-    return processMemberName(operands);
-  case spirv::Opcode::OpMemoryModel:
-    return processMemoryModel(operands);
-  case spirv::Opcode::OpEntryPoint:
-  case spirv::Opcode::OpExecutionMode:
-    if (deferInstructions) {
-      deferredInstructions.emplace_back(opcode, operands);
-      return success();
-    }
-    break;
-  case spirv::Opcode::OpVariable:
-    if (isa<spirv::ModuleOp>(opBuilder.getBlock()->getParentOp())) {
-      return processGlobalVariable(operands);
-    }
-    break;
-  case spirv::Opcode::OpLine:
-    return processDebugLine(operands);
-  case spirv::Opcode::OpNoLine:
-    return clearDebugLine();
-  case spirv::Opcode::OpName:
-    return processName(operands);
-  case spirv::Opcode::OpString:
-    return processDebugString(operands);
-  case spirv::Opcode::OpModuleProcessed:
-  case spirv::Opcode::OpSource:
-  case spirv::Opcode::OpSourceContinued:
-  case spirv::Opcode::OpSourceExtension:
-    // TODO: This is debug information embedded in the binary which should be
-    // translated into the spv.module.
-    return success();
-  case spirv::Opcode::OpTypeVoid:
-  case spirv::Opcode::OpTypeBool:
-  case spirv::Opcode::OpTypeInt:
-  case spirv::Opcode::OpTypeFloat:
-  case spirv::Opcode::OpTypeVector:
-  case spirv::Opcode::OpTypeMatrix:
-  case spirv::Opcode::OpTypeArray:
-  case spirv::Opcode::OpTypeFunction:
-  case spirv::Opcode::OpTypeRuntimeArray:
-  case spirv::Opcode::OpTypeStruct:
-  case spirv::Opcode::OpTypePointer:
-  case spirv::Opcode::OpTypeCooperativeMatrixNV:
-    return processType(opcode, operands);
-  case spirv::Opcode::OpConstant:
-    return processConstant(operands, /*isSpec=*/false);
-  case spirv::Opcode::OpSpecConstant:
-    return processConstant(operands, /*isSpec=*/true);
-  case spirv::Opcode::OpConstantComposite:
-    return processConstantComposite(operands);
-  case spirv::Opcode::OpSpecConstantComposite:
-    return processSpecConstantComposite(operands);
-  case spirv::Opcode::OpConstantTrue:
-    return processConstantBool(/*isTrue=*/true, operands, /*isSpec=*/false);
-  case spirv::Opcode::OpSpecConstantTrue:
-    return processConstantBool(/*isTrue=*/true, operands, /*isSpec=*/true);
-  case spirv::Opcode::OpConstantFalse:
-    return processConstantBool(/*isTrue=*/false, operands, /*isSpec=*/false);
-  case spirv::Opcode::OpSpecConstantFalse:
-    return processConstantBool(/*isTrue=*/false, operands, /*isSpec=*/true);
-  case spirv::Opcode::OpConstantNull:
-    return processConstantNull(operands);
-  case spirv::Opcode::OpDecorate:
-    return processDecoration(operands);
-  case spirv::Opcode::OpMemberDecorate:
-    return processMemberDecoration(operands);
-  case spirv::Opcode::OpFunction:
-    return processFunction(operands);
-  case spirv::Opcode::OpLabel:
-    return processLabel(operands);
-  case spirv::Opcode::OpBranch:
-    return processBranch(operands);
-  case spirv::Opcode::OpBranchConditional:
-    return processBranchConditional(operands);
-  case spirv::Opcode::OpSelectionMerge:
-    return processSelectionMerge(operands);
-  case spirv::Opcode::OpLoopMerge:
-    return processLoopMerge(operands);
-  case spirv::Opcode::OpPhi:
-    return processPhi(operands);
-  case spirv::Opcode::OpUndef:
-    return processUndef(operands);
-  case spirv::Opcode::OpTypeForwardPointer:
-    return processTypeForwardPointer(operands);
-  default:
-    break;
-  }
-  return dispatchToAutogenDeserialization(opcode, operands);
-}
-
-LogicalResult
-Deserializer::processOpWithoutGrammarAttr(ArrayRef<uint32_t> words,
-                                          StringRef opName, bool hasResult,
-                                          unsigned numOperands) {
-  SmallVector<Type, 1> resultTypes;
-  uint32_t valueID = 0;
-
-  size_t wordIndex= 0;
-  if (hasResult) {
-    if (wordIndex >= words.size())
-      return emitError(unknownLoc,
-                       "expected result type <id> while deserializing for ")
-             << opName;
-
-    // Decode the type <id>
-    auto type = getType(words[wordIndex]);
-    if (!type)
-      return emitError(unknownLoc, "unknown type result <id>: ")
-             << words[wordIndex];
-    resultTypes.push_back(type);
-    ++wordIndex;
-
-    // Decode the result <id>
-    if (wordIndex >= words.size())
-      return emitError(unknownLoc,
-                       "expected result <id> while deserializing for ")
-             << opName;
-    valueID = words[wordIndex];
-    ++wordIndex;
-  }
-
-  SmallVector<Value, 4> operands;
-  SmallVector<NamedAttribute, 4> attributes;
-
-  // Decode operands
-  size_t operandIndex = 0;
-  for (; operandIndex < numOperands && wordIndex < words.size();
-       ++operandIndex, ++wordIndex) {
-    auto arg = getValue(words[wordIndex]);
-    if (!arg)
-      return emitError(unknownLoc, "unknown result <id>: ") << words[wordIndex];
-    operands.push_back(arg);
-  }
-  if (operandIndex != numOperands) {
-    return emitError(
-               unknownLoc,
-               "found less operands than expected when deserializing for ")
-           << opName << "; only " << operandIndex << " of " << numOperands
-           << " processed";
-  }
-  if (wordIndex != words.size()) {
-    return emitError(
-               unknownLoc,
-               "found more operands than expected when deserializing for ")
-           << opName << "; only " << wordIndex << " of " << words.size()
-           << " processed";
-  }
-
-  // Attach attributes from decorations
-  if (decorations.count(valueID)) {
-    auto attrs = decorations[valueID].getAttrs();
-    attributes.append(attrs.begin(), attrs.end());
-  }
-
-  // Create the op and update bookkeeping maps
-  Location loc = createFileLineColLoc(opBuilder);
-  OperationState opState(loc, opName);
-  opState.addOperands(operands);
-  if (hasResult)
-    opState.addTypes(resultTypes);
-  opState.addAttributes(attributes);
-  Operation *op = opBuilder.createOperation(opState);
-  if (hasResult)
-    valueMap[valueID] = op->getResult(0);
-
-  if (op->hasTrait<OpTrait::IsTerminator>())
-    clearDebugLine();
-
-  return success();
-}
-
-LogicalResult Deserializer::processUndef(ArrayRef<uint32_t> operands) {
-  if (operands.size() != 2) {
-    return emitError(unknownLoc, "OpUndef instruction must have two operands");
-  }
-  auto type = getType(operands[0]);
-  if (!type) {
-    return emitError(unknownLoc, "unknown type <id> with OpUndef instruction");
-  }
-  undefMap[operands[1]] = type;
-  return success();
-}
-
-LogicalResult
-Deserializer::processTypeForwardPointer(ArrayRef<uint32_t> operands) {
-  if (operands.size() != 2)
-    return emitError(unknownLoc,
-                     "OpTypeForwardPointer instruction must have two operands");
-
-  typeForwardPointerIDs.insert(operands[0]);
-  // TODO: Use the 2nd operand (Storage Class) to validate the OpTypePointer
-  // instruction that defines the actual type.
-
-  return success();
-}
-
-LogicalResult Deserializer::processExtInst(ArrayRef<uint32_t> operands) {
-  if (operands.size() < 4) {
-    return emitError(unknownLoc,
-                     "OpExtInst must have at least 4 operands, result type "
-                     "<id>, result <id>, set <id> and instruction opcode");
-  }
-  if (!extendedInstSets.count(operands[2])) {
-    return emitError(unknownLoc, "undefined set <id> in OpExtInst");
-  }
-  SmallVector<uint32_t, 4> slicedOperands;
-  slicedOperands.append(operands.begin(), std::next(operands.begin(), 2));
-  slicedOperands.append(std::next(operands.begin(), 4), operands.end());
-  return dispatchToExtensionSetAutogenDeserialization(
-      extendedInstSets[operands[2]], operands[3], slicedOperands);
-}
-
-namespace {
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::EntryPointOp>(ArrayRef<uint32_t> words) {
-  unsigned wordIndex = 0;
-  if (wordIndex >= words.size()) {
-    return emitError(unknownLoc,
-                     "missing Execution Model specification in OpEntryPoint");
-  }
-  auto execModel = opBuilder.getI32IntegerAttr(words[wordIndex++]);
-  if (wordIndex >= words.size()) {
-    return emitError(unknownLoc, "missing <id> in OpEntryPoint");
-  }
-  // Get the function <id>
-  auto fnID = words[wordIndex++];
-  // Get the function name
-  auto fnName = decodeStringLiteral(words, wordIndex);
-  // Verify that the function <id> matches the fnName
-  auto parsedFunc = getFunction(fnID);
-  if (!parsedFunc) {
-    return emitError(unknownLoc, "no function matching <id> ") << fnID;
-  }
-  if (parsedFunc.getName() != fnName) {
-    return emitError(unknownLoc, "function name mismatch between OpEntryPoint "
-                                 "and OpFunction with <id> ")
-           << fnID << ": " << fnName << " vs. " << parsedFunc.getName();
-  }
-  SmallVector<Attribute, 4> interface;
-  while (wordIndex < words.size()) {
-    auto arg = getGlobalVariable(words[wordIndex]);
-    if (!arg) {
-      return emitError(unknownLoc, "undefined result <id> ")
-             << words[wordIndex] << " while decoding OpEntryPoint";
-    }
-    interface.push_back(opBuilder.getSymbolRefAttr(arg.getOperation()));
-    wordIndex++;
-  }
-  opBuilder.create<spirv::EntryPointOp>(unknownLoc, execModel,
-                                        opBuilder.getSymbolRefAttr(fnName),
-                                        opBuilder.getArrayAttr(interface));
-  return success();
-}
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::ExecutionModeOp>(ArrayRef<uint32_t> words) {
-  unsigned wordIndex = 0;
-  if (wordIndex >= words.size()) {
-    return emitError(unknownLoc,
-                     "missing function result <id> in OpExecutionMode");
-  }
-  // Get the function <id> to get the name of the function
-  auto fnID = words[wordIndex++];
-  auto fn = getFunction(fnID);
-  if (!fn) {
-    return emitError(unknownLoc, "no function matching <id> ") << fnID;
-  }
-  // Get the Execution mode
-  if (wordIndex >= words.size()) {
-    return emitError(unknownLoc, "missing Execution Mode in OpExecutionMode");
-  }
-  auto execMode = opBuilder.getI32IntegerAttr(words[wordIndex++]);
-
-  // Get the values
-  SmallVector<Attribute, 4> attrListElems;
-  while (wordIndex < words.size()) {
-    attrListElems.push_back(opBuilder.getI32IntegerAttr(words[wordIndex++]));
-  }
-  auto values = opBuilder.getArrayAttr(attrListElems);
-  opBuilder.create<spirv::ExecutionModeOp>(
-      unknownLoc, opBuilder.getSymbolRefAttr(fn.getName()), execMode, values);
-  return success();
-}
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::ControlBarrierOp>(ArrayRef<uint32_t> operands) {
-  if (operands.size() != 3) {
-    return emitError(
-        unknownLoc,
-        "OpControlBarrier must have execution scope <id>, memory scope <id> "
-        "and memory semantics <id>");
-  }
-
-  SmallVector<IntegerAttr, 3> argAttrs;
-  for (auto operand : operands) {
-    auto argAttr = getConstantInt(operand);
-    if (!argAttr) {
-      return emitError(unknownLoc,
-                       "expected 32-bit integer constant from <id> ")
-             << operand << " for OpControlBarrier";
-    }
-    argAttrs.push_back(argAttr);
-  }
-
-  opBuilder.create<spirv::ControlBarrierOp>(unknownLoc, argAttrs[0],
-                                            argAttrs[1], argAttrs[2]);
-  return success();
-}
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::FunctionCallOp>(ArrayRef<uint32_t> operands) {
-  if (operands.size() < 3) {
-    return emitError(unknownLoc,
-                     "OpFunctionCall must have at least 3 operands");
-  }
-
-  Type resultType = getType(operands[0]);
-  if (!resultType) {
-    return emitError(unknownLoc, "undefined result type from <id> ")
-           << operands[0];
-  }
-
-  // Use null type to mean no result type.
-  if (isVoidType(resultType))
-    resultType = nullptr;
-
-  auto resultID = operands[1];
-  auto functionID = operands[2];
-
-  auto functionName = getFunctionSymbol(functionID);
-
-  SmallVector<Value, 4> arguments;
-  for (auto operand : llvm::drop_begin(operands, 3)) {
-    auto value = getValue(operand);
-    if (!value) {
-      return emitError(unknownLoc, "unknown <id> ")
-             << operand << " used by OpFunctionCall";
-    }
-    arguments.push_back(value);
-  }
-
-  auto opFunctionCall = opBuilder.create<spirv::FunctionCallOp>(
-      unknownLoc, resultType, opBuilder.getSymbolRefAttr(functionName),
-      arguments);
-
-  if (resultType)
-    valueMap[resultID] = opFunctionCall.getResult(0);
-  return success();
-}
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::MemoryBarrierOp>(ArrayRef<uint32_t> operands) {
-  if (operands.size() != 2) {
-    return emitError(unknownLoc, "OpMemoryBarrier must have memory scope <id> "
-                                 "and memory semantics <id>");
-  }
-
-  SmallVector<IntegerAttr, 2> argAttrs;
-  for (auto operand : operands) {
-    auto argAttr = getConstantInt(operand);
-    if (!argAttr) {
-      return emitError(unknownLoc,
-                       "expected 32-bit integer constant from <id> ")
-             << operand << " for OpMemoryBarrier";
-    }
-    argAttrs.push_back(argAttr);
-  }
-
-  opBuilder.create<spirv::MemoryBarrierOp>(unknownLoc, argAttrs[0],
-                                           argAttrs[1]);
-  return success();
-}
-
-template <>
-LogicalResult
-Deserializer::processOp<spirv::CopyMemoryOp>(ArrayRef<uint32_t> words) {
-  SmallVector<Type, 1> resultTypes;
-  size_t wordIndex = 0;
-  SmallVector<Value, 4> operands;
-  SmallVector<NamedAttribute, 4> attributes;
-
-  if (wordIndex < words.size()) {
-    auto arg = getValue(words[wordIndex]);
-
-    if (!arg) {
-      return emitError(unknownLoc, "unknown result <id> : ")
-             << words[wordIndex];
-    }
-
-    operands.push_back(arg);
-    wordIndex++;
-  }
-
-  if (wordIndex < words.size()) {
-    auto arg = getValue(words[wordIndex]);
-
-    if (!arg) {
-      return emitError(unknownLoc, "unknown result <id> : ")
-             << words[wordIndex];
-    }
-
-    operands.push_back(arg);
-    wordIndex++;
-  }
-
-  bool isAlignedAttr = false;
-
-  if (wordIndex < words.size()) {
-    auto attrValue = words[wordIndex++];
-    attributes.push_back(opBuilder.getNamedAttr(
-        "memory_access", opBuilder.getI32IntegerAttr(attrValue)));
-    isAlignedAttr = (attrValue == 2);
-  }
-
-  if (isAlignedAttr && wordIndex < words.size()) {
-    attributes.push_back(opBuilder.getNamedAttr(
-        "alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
-  }
-
-  if (wordIndex < words.size()) {
-    attributes.push_back(opBuilder.getNamedAttr(
-        "source_memory_access",
-        opBuilder.getI32IntegerAttr(words[wordIndex++])));
-  }
-
-  if (wordIndex < words.size()) {
-    attributes.push_back(opBuilder.getNamedAttr(
-        "source_alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
-  }
-
-  if (wordIndex != words.size()) {
-    return emitError(unknownLoc,
-                     "found more operands than expected when deserializing "
-                     "spirv::CopyMemoryOp, only ")
-           << wordIndex << " of " << words.size() << " processed";
-  }
-
-  Location loc = createFileLineColLoc(opBuilder);
-  opBuilder.create<spirv::CopyMemoryOp>(loc, resultTypes, operands, attributes);
-
-  return success();
-}
-
-// Pull in auto-generated Deserializer::dispatchToAutogenDeserialization() and
-// various Deserializer::processOp<...>() specializations.
-#define GET_DESERIALIZATION_FNS
-#include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
-
-} // namespace
-
-namespace mlir {
-spirv::OwningSPIRVModuleRef spirv::deserialize(ArrayRef<uint32_t> binary,
-                                               MLIRContext *context) {
-  Deserializer deserializer(binary, context);
-
-  if (failed(deserializer.deserialize()))
-    return nullptr;
-
-  return deserializer.collect();
-}
-} // namespace mlir

mlir/lib/Target/SPIRV/Serialization/CMakeLists.txt

+add_mlir_translation_library(MLIRSPIRVSerialization
+  Serialization.cpp
+
+  DEPENDS
+  MLIRSPIRVSerializationGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSPIRV
+  MLIRSPIRVBinaryUtils
+  MLIRSupport
+  MLIRTranslation
+  )
+
+

mlir/lib/Target/SPIRV/Serialization/Serialization.cpp

 //===- Serializer.cpp - MLIR SPIR-V Serialization -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the MLIR SPIR-V module to SPIR-V binary serialization.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/Serialization.h"
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/ADT/bit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "spirv-serialization"
 
 using namespace mlir;
 
 /// Encodes an SPIR-V instruction with the given `opcode` and `operands` into
 /// the given `binary` vector.
 static LogicalResult encodeInstructionInto(SmallVectorImpl<uint32_t> &binary,
                                            spirv::Opcode op,
                                            ArrayRef<uint32_t> operands) {
   uint32_t wordCount = 1 + operands.size();
   binary.push_back(spirv::getPrefixedOpcode(wordCount, op));
   binary.append(operands.begin(), operands.end());
   return success();
 }
 
 /// A pre-order depth-first visitor function for processing basic blocks.
 ///
 /// Visits the basic blocks starting from the given `headerBlock` in pre-order
 /// depth-first manner and calls `blockHandler` on each block. Skips handling
 /// blocks in the `skipBlocks` list. If `skipHeader` is true, `blockHandler`
 /// will not be invoked in `headerBlock` but still handles all `headerBlock`'s
 /// successors.
 ///
 /// SPIR-V spec "2.16.1. Universal Validation Rules" requires that "the order
 /// of blocks in a function must satisfy the rule that blocks appear before
 /// all blocks they dominate." This can be achieved by a pre-order CFG
 /// traversal algorithm. To make the serialization output more logical and
 /// readable to human, we perform depth-first CFG traversal and delay the
 /// serialization of the merge block and the continue block, if exists, until
 /// after all other blocks have been processed.
 static LogicalResult
 visitInPrettyBlockOrder(Block *headerBlock,
                         function_ref<LogicalResult(Block *)> blockHandler,
                         bool skipHeader = false, BlockRange skipBlocks = {}) {
   llvm::df_iterator_default_set<Block *, 4> doneBlocks;
   doneBlocks.insert(skipBlocks.begin(), skipBlocks.end());
 
   for (Block *block : llvm::depth_first_ext(headerBlock, doneBlocks)) {
     if (skipHeader && block == headerBlock)
       continue;
     if (failed(blockHandler(block)))
       return failure();
   }
   return success();
 }
 
 /// Returns the merge block if the given `op` is a structured control flow op.
 /// Otherwise returns nullptr.
 static Block *getStructuredControlFlowOpMergeBlock(Operation *op) {
   if (auto selectionOp = dyn_cast<spirv::SelectionOp>(op))
     return selectionOp.getMergeBlock();
   if (auto loopOp = dyn_cast<spirv::LoopOp>(op))
     return loopOp.getMergeBlock();
   return nullptr;
 }
 
 /// Given a predecessor `block` for a block with arguments, returns the block
 /// that should be used as the parent block for SPIR-V OpPhi instructions
 /// corresponding to the block arguments.
 static Block *getPhiIncomingBlock(Block *block) {
   // If the predecessor block in question is the entry block for a spv.loop,
   // we jump to this spv.loop from its enclosing block.
   if (block->isEntryBlock()) {
     if (auto loopOp = dyn_cast<spirv::LoopOp>(block->getParentOp())) {
       // Then the incoming parent block for OpPhi should be the merge block of
       // the structured control flow op before this loop.
       Operation *op = loopOp.getOperation();
       while ((op = op->getPrevNode()) != nullptr)
         if (Block *incomingBlock = getStructuredControlFlowOpMergeBlock(op))
           return incomingBlock;
       // Or the enclosing block itself if no structured control flow ops
       // exists before this loop.
       return loopOp->getBlock();
     }
   }
 
   // Otherwise, we jump from the given predecessor block. Try to see if there is
   // a structured control flow op inside it.
   for (Operation &op : llvm::reverse(block->getOperations())) {
     if (Block *incomingBlock = getStructuredControlFlowOpMergeBlock(&op))
       return incomingBlock;
   }
   return block;
 }
 
 namespace {
 
 /// A SPIR-V module serializer.
 ///
 /// A SPIR-V binary module is a single linear stream of instructions; each
 /// instruction is composed of 32-bit words with the layout:
 ///
 ///   | <word-count>|<opcode> |  <operand>   |  <operand>   | ... |
 ///   | <------ word -------> | <-- word --> | <-- word --> | ... |
 ///
 /// For the first word, the 16 high-order bits are the word count of the
 /// instruction, the 16 low-order bits are the opcode enumerant. The
 /// instructions then belong to different sections, which must be laid out in
 /// the particular order as specified in "2.4 Logical Layout of a Module" of
 /// the SPIR-V spec.
 class Serializer {
 public:
   /// Creates a serializer for the given SPIR-V `module`.
   explicit Serializer(spirv::ModuleOp module, bool emitDebugInfo = false);
 
   /// Serializes the remembered SPIR-V module.
   LogicalResult serialize();
 
   /// Collects the final SPIR-V `binary`.
   void collect(SmallVectorImpl<uint32_t> &binary);
 
 #ifndef NDEBUG
   /// (For debugging) prints each value and its corresponding result <id>.
   void printValueIDMap(raw_ostream &os);
 #endif
 
 private:
   // Note that there are two main categories of methods in this class:
   // * process*() methods are meant to fully serialize a SPIR-V module entity
   //   (header, type, op, etc.). They update internal vectors containing
   //   different binary sections. They are not meant to be called except the
   //   top-level serialization loop.
   // * prepare*() methods are meant to be helpers that prepare for serializing
   //   certain entity. They may or may not update internal vectors containing
   //   different binary sections. They are meant to be called among themselves
   //   or by other process*() methods for subtasks.
 
   //===--------------------------------------------------------------------===//
   // <id>
   //===--------------------------------------------------------------------===//
 
   // Note that it is illegal to use id <0> in SPIR-V binary module. Various
   // methods in this class, if using SPIR-V word (uint32_t) as interface,
   // check or return id <0> to indicate error in processing.
 
   /// Consumes the next unused <id>. This method will never return 0.
   uint32_t getNextID() { return nextID++; }
 
   //===--------------------------------------------------------------------===//
   // Module structure
   //===--------------------------------------------------------------------===//
 
   uint32_t getSpecConstID(StringRef constName) const {
     return specConstIDMap.lookup(constName);
   }
 
   uint32_t getVariableID(StringRef varName) const {
     return globalVarIDMap.lookup(varName);
   }
 
   uint32_t getFunctionID(StringRef fnName) const {
     return funcIDMap.lookup(fnName);
   }
 
   /// Gets the <id> for the function with the given name. Assigns the next
   /// available <id> if the function haven't been deserialized.
   uint32_t getOrCreateFunctionID(StringRef fnName);
 
   void processCapability();
 
   void processDebugInfo();
 
   void processExtension();
 
   void processMemoryModel();
 
   LogicalResult processConstantOp(spirv::ConstantOp op);
 
   LogicalResult processSpecConstantOp(spirv::SpecConstantOp op);
 
   LogicalResult
   processSpecConstantCompositeOp(spirv::SpecConstantCompositeOp op);
 
   /// SPIR-V dialect supports OpUndef using spv.UndefOp that produces a SSA
   /// value to use with other operations. The SPIR-V spec recommends that
   /// OpUndef be generated at module level. The serialization generates an
   /// OpUndef for each type needed at module level.
   LogicalResult processUndefOp(spirv::UndefOp op);
 
   /// Emit OpName for the given `resultID`.
   LogicalResult processName(uint32_t resultID, StringRef name);
 
   /// Processes a SPIR-V function op.
   LogicalResult processFuncOp(spirv::FuncOp op);
 
   LogicalResult processVariableOp(spirv::VariableOp op);
 
   /// Process a SPIR-V GlobalVariableOp
   LogicalResult processGlobalVariableOp(spirv::GlobalVariableOp varOp);
 
   /// Process attributes that translate to decorations on the result <id>
   LogicalResult processDecoration(Location loc, uint32_t resultID,
                                   NamedAttribute attr);
 
   template <typename DType>
   LogicalResult processTypeDecoration(Location loc, DType type,
                                       uint32_t resultId) {
     return emitError(loc, "unhandled decoration for type:") << type;
   }
 
   /// Process member decoration
   LogicalResult processMemberDecoration(
       uint32_t structID,
       const spirv::StructType::MemberDecorationInfo &memberDecorationInfo);
 
   //===--------------------------------------------------------------------===//
   // Types
   //===--------------------------------------------------------------------===//
 
   uint32_t getTypeID(Type type) const { return typeIDMap.lookup(type); }
 
   Type getVoidType() { return mlirBuilder.getNoneType(); }
 
   bool isVoidType(Type type) const { return type.isa<NoneType>(); }
 
   /// Returns true if the given type is a pointer type to a struct in some
   /// interface storage class.
   bool isInterfaceStructPtrType(Type type) const;
 
   /// Main dispatch method for serializing a type. The result <id> of the
   /// serialized type will be returned as `typeID`.
   LogicalResult processType(Location loc, Type type, uint32_t &typeID);
   LogicalResult processTypeImpl(Location loc, Type type, uint32_t &typeID,
                                 llvm::SetVector<StringRef> &serializationCtx);
 
   /// Method for preparing basic SPIR-V type serialization. Returns the type's
   /// opcode and operands for the instruction via `typeEnum` and `operands`.
   LogicalResult prepareBasicType(Location loc, Type type, uint32_t resultID,
                                  spirv::Opcode &typeEnum,
                                  SmallVectorImpl<uint32_t> &operands,
                                  bool &deferSerialization,
                                  llvm::SetVector<StringRef> &serializationCtx);
 
   LogicalResult prepareFunctionType(Location loc, FunctionType type,
                                     spirv::Opcode &typeEnum,
                                     SmallVectorImpl<uint32_t> &operands);
 
   //===--------------------------------------------------------------------===//
   // Constant
   //===--------------------------------------------------------------------===//
 
   uint32_t getConstantID(Attribute value) const {
     return constIDMap.lookup(value);
   }
 
   /// Main dispatch method for processing a constant with the given `constType`
   /// and `valueAttr`. `constType` is needed here because we can interpret the
   /// `valueAttr` as a different type than the type of `valueAttr` itself; for
   /// example, ArrayAttr, whose type is NoneType, is used for spirv::ArrayType
   /// constants.
   uint32_t prepareConstant(Location loc, Type constType, Attribute valueAttr);
 
   /// Prepares array attribute serialization. This method emits corresponding
   /// OpConstant* and returns the result <id> associated with it. Returns 0 if
   /// failed.
   uint32_t prepareArrayConstant(Location loc, Type constType, ArrayAttr attr);
 
   /// Prepares bool/int/float DenseElementsAttr serialization. This method
   /// iterates the DenseElementsAttr to construct the constant array, and
   /// returns the result <id>  associated with it. Returns 0 if failed. Note
   /// that the size of `index` must match the rank.
   /// TODO: Consider to enhance splat elements cases. For splat cases,
   /// we don't need to loop over all elements, especially when the splat value
   /// is zero. We can use OpConstantNull when the value is zero.
   uint32_t prepareDenseElementsConstant(Location loc, Type constType,
                                         DenseElementsAttr valueAttr, int dim,
                                         MutableArrayRef<uint64_t> index);
 
   /// Prepares scalar attribute serialization. This method emits corresponding
   /// OpConstant* and returns the result <id> associated with it. Returns 0 if
   /// the attribute is not for a scalar bool/integer/float value. If `isSpec` is
   /// true, then the constant will be serialized as a specialization constant.
   uint32_t prepareConstantScalar(Location loc, Attribute valueAttr,
                                  bool isSpec = false);
 
   uint32_t prepareConstantBool(Location loc, BoolAttr boolAttr,
                                bool isSpec = false);
 
   uint32_t prepareConstantInt(Location loc, IntegerAttr intAttr,
                               bool isSpec = false);
 
   uint32_t prepareConstantFp(Location loc, FloatAttr floatAttr,
                              bool isSpec = false);
 
   //===--------------------------------------------------------------------===//
   // Control flow
   //===--------------------------------------------------------------------===//
 
   /// Returns the result <id> for the given block.
   uint32_t getBlockID(Block *block) const { return blockIDMap.lookup(block); }
 
   /// Returns the result <id> for the given block. If no <id> has been assigned,
   /// assigns the next available <id>
   uint32_t getOrCreateBlockID(Block *block);
 
   /// Processes the given `block` and emits SPIR-V instructions for all ops
   /// inside. Does not emit OpLabel for this block if `omitLabel` is true.
   /// `actionBeforeTerminator` is a callback that will be invoked before
   /// handling the terminator op. It can be used to inject the Op*Merge
   /// instruction if this is a SPIR-V selection/loop header block.
   LogicalResult
   processBlock(Block *block, bool omitLabel = false,
                function_ref<void()> actionBeforeTerminator = nullptr);
 
   /// Emits OpPhi instructions for the given block if it has block arguments.
   LogicalResult emitPhiForBlockArguments(Block *block);
 
   LogicalResult processSelectionOp(spirv::SelectionOp selectionOp);
 
   LogicalResult processLoopOp(spirv::LoopOp loopOp);
 
   LogicalResult processBranchConditionalOp(spirv::BranchConditionalOp);
 
   LogicalResult processBranchOp(spirv::BranchOp branchOp);
 
   //===--------------------------------------------------------------------===//
   // Operations
   //===--------------------------------------------------------------------===//
 
   LogicalResult encodeExtensionInstruction(Operation *op,
                                            StringRef extensionSetName,
                                            uint32_t opcode,
                                            ArrayRef<uint32_t> operands);
 
   uint32_t getValueID(Value val) const { return valueIDMap.lookup(val); }
 
   LogicalResult processAddressOfOp(spirv::AddressOfOp addressOfOp);
 
   LogicalResult processReferenceOfOp(spirv::ReferenceOfOp referenceOfOp);
 
   /// Main dispatch method for serializing an operation.
   LogicalResult processOperation(Operation *op);
 
   /// Serializes an operation `op` as core instruction with `opcode` if
   /// `extInstSet` is empty. Otherwise serializes it as an extended instruction
   /// with `opcode` from `extInstSet`.
   /// This method is a generic one for dispatching any SPIR-V ops that has no
   /// variadic operands and attributes in TableGen definitions.
   LogicalResult processOpWithoutGrammarAttr(Operation *op, StringRef extInstSet,
                                             uint32_t opcode);
 
   /// Dispatches to the serialization function for an operation in SPIR-V
   /// dialect that is a mirror of an instruction in the SPIR-V spec. This is
   /// auto-generated from ODS. Dispatch is handled for all operations in SPIR-V
   /// dialect that have hasOpcode == 1.
   LogicalResult dispatchToAutogenSerialization(Operation *op);
 
   /// Serializes an operation in the SPIR-V dialect that is a mirror of an
   /// instruction in the SPIR-V spec. This is auto generated if hasOpcode == 1
   /// and autogenSerialization == 1 in ODS.
   template <typename OpTy>
   LogicalResult processOp(OpTy op) {
     return op.emitError("unsupported op serialization");
   }
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emits an OpDecorate instruction to decorate the given `target` with the
   /// given `decoration`.
   LogicalResult emitDecoration(uint32_t target, spirv::Decoration decoration,
                                ArrayRef<uint32_t> params = {});
 
   /// Emits an OpLine instruction with the given `loc` location information into
   /// the given `binary` vector.
   LogicalResult emitDebugLine(SmallVectorImpl<uint32_t> &binary, Location loc);
 
 private:
   /// The SPIR-V module to be serialized.
   spirv::ModuleOp module;
 
   /// An MLIR builder for getting MLIR constructs.
   mlir::Builder mlirBuilder;
 
   /// A flag which indicates if the debuginfo should be emitted.
   bool emitDebugInfo = false;
 
   /// A flag which indicates if the last processed instruction was a merge
   /// instruction.
   /// According to SPIR-V spec: "If a branch merge instruction is used, the last
   /// OpLine in the block must be before its merge instruction".
   bool lastProcessedWasMergeInst = false;
 
   /// The <id> of the OpString instruction, which specifies a file name, for
   /// use by other debug instructions.
   uint32_t fileID = 0;
 
   /// The next available result <id>.
   uint32_t nextID = 1;
 
   // The following are for different SPIR-V instruction sections. They follow
   // the logical layout of a SPIR-V module.
 
   SmallVector<uint32_t, 4> capabilities;
   SmallVector<uint32_t, 0> extensions;
   SmallVector<uint32_t, 0> extendedSets;
   SmallVector<uint32_t, 3> memoryModel;
   SmallVector<uint32_t, 0> entryPoints;
   SmallVector<uint32_t, 4> executionModes;
   SmallVector<uint32_t, 0> debug;
   SmallVector<uint32_t, 0> names;
   SmallVector<uint32_t, 0> decorations;
   SmallVector<uint32_t, 0> typesGlobalValues;
   SmallVector<uint32_t, 0> functions;
 
   /// Recursive struct references are serialized as OpTypePointer instructions
   /// to the recursive struct type. However, the OpTypePointer instruction
   /// cannot be emitted before the recursive struct's OpTypeStruct.
   /// RecursiveStructPointerInfo stores the data needed to emit such
   /// OpTypePointer instructions after forward references to such types.
   struct RecursiveStructPointerInfo {
     uint32_t pointerTypeID;
     spirv::StorageClass storageClass;
   };
 
   // Maps spirv::StructType to its recursive reference member info.
   DenseMap<Type, SmallVector<RecursiveStructPointerInfo, 0>>
       recursiveStructInfos;
 
   /// `functionHeader` contains all the instructions that must be in the first
   /// block in the function, and `functionBody` contains the rest. After
   /// processing FuncOp, the encoded instructions of a function are appended to
   /// `functions`. An example of instructions in `functionHeader` in order:
   /// OpFunction ...
   /// OpFunctionParameter ...
   /// OpFunctionParameter ...
   /// OpLabel ...
   /// OpVariable ...
   /// OpVariable ...
   SmallVector<uint32_t, 0> functionHeader;
   SmallVector<uint32_t, 0> functionBody;
 
   /// Map from type used in SPIR-V module to their <id>s.
   DenseMap<Type, uint32_t> typeIDMap;
 
   /// Map from constant values to their <id>s.
   DenseMap<Attribute, uint32_t> constIDMap;
 
   /// Map from specialization constant names to their <id>s.
   llvm::StringMap<uint32_t> specConstIDMap;
 
   /// Map from GlobalVariableOps name to <id>s.
   llvm::StringMap<uint32_t> globalVarIDMap;
 
   /// Map from FuncOps name to <id>s.
   llvm::StringMap<uint32_t> funcIDMap;
 
   /// Map from blocks to their <id>s.
   DenseMap<Block *, uint32_t> blockIDMap;
 
   /// Map from the Type to the <id> that represents undef value of that type.
   DenseMap<Type, uint32_t> undefValIDMap;
 
   /// Map from results of normal operations to their <id>s.
   DenseMap<Value, uint32_t> valueIDMap;
 
   /// Map from extended instruction set name to <id>s.
   llvm::StringMap<uint32_t> extendedInstSetIDMap;
 
   /// Map from values used in OpPhi instructions to their offset in the
   /// `functions` section.
   ///
   /// When processing a block with arguments, we need to emit OpPhi
   /// instructions to record the predecessor block <id>s and the values they
   /// send to the block in question. But it's not guaranteed all values are
   /// visited and thus assigned result <id>s. So we need this list to capture
   /// the offsets into `functions` where a value is used so that we can fix it
   /// up later after processing all the blocks in a function.
   ///
   /// More concretely, say if we are visiting the following blocks:
   ///
   /// ```mlir
   /// ^phi(%arg0: i32):
   ///   ...
   /// ^parent1:
   ///   ...
   ///   spv.Branch ^phi(%val0: i32)
   /// ^parent2:
   ///   ...
   ///   spv.Branch ^phi(%val1: i32)
   /// ```
   ///
   /// When we are serializing the `^phi` block, we need to emit at the beginning
   /// of the block OpPhi instructions which has the following parameters:
   ///
   /// OpPhi id-for-i32 id-for-%arg0 id-for-%val0 id-for-^parent1
   ///                               id-for-%val1 id-for-^parent2
   ///
   /// But we don't know the <id> for %val0 and %val1 yet. One way is to visit
   /// all the blocks twice and use the first visit to assign an <id> to each
   /// value. But it's paying the overheads just for OpPhi emission. Instead,
   /// we still visit the blocks once for emission. When we emit the OpPhi
   /// instructions, we use 0 as a placeholder for the <id>s for %val0 and %val1.
   /// At the same time, we record their offsets in the emitted binary (which is
   /// placed inside `functions`) here. And then after emitting all blocks, we
   /// replace the dummy <id> 0 with the real result <id> by overwriting
   /// `functions[offset]`.
   DenseMap<Value, SmallVector<size_t, 1>> deferredPhiValues;
 };
 } // namespace
 
 Serializer::Serializer(spirv::ModuleOp module, bool emitDebugInfo)
     : module(module), mlirBuilder(module.getContext()),
       emitDebugInfo(emitDebugInfo) {}
 
 LogicalResult Serializer::serialize() {
   LLVM_DEBUG(llvm::dbgs() << "+++ starting serialization +++\n");
 
   if (failed(module.verify()))
     return failure();
 
   // TODO: handle the other sections
   processCapability();
   processExtension();
   processMemoryModel();
   processDebugInfo();
 
   // Iterate over the module body to serialize it. Assumptions are that there is
   // only one basic block in the moduleOp
   for (auto &op : module.getBlock()) {
     if (failed(processOperation(&op))) {
       return failure();
     }
   }
 
   LLVM_DEBUG(llvm::dbgs() << "+++ completed serialization +++\n");
   return success();
 }
 
 void Serializer::collect(SmallVectorImpl<uint32_t> &binary) {
   auto moduleSize = spirv::kHeaderWordCount + capabilities.size() +
                     extensions.size() + extendedSets.size() +
                     memoryModel.size() + entryPoints.size() +
                     executionModes.size() + decorations.size() +
                     typesGlobalValues.size() + functions.size();
 
   binary.clear();
   binary.reserve(moduleSize);
 
   spirv::appendModuleHeader(binary, module.vce_triple()->getVersion(), nextID);
   binary.append(capabilities.begin(), capabilities.end());
   binary.append(extensions.begin(), extensions.end());
   binary.append(extendedSets.begin(), extendedSets.end());
   binary.append(memoryModel.begin(), memoryModel.end());
   binary.append(entryPoints.begin(), entryPoints.end());
   binary.append(executionModes.begin(), executionModes.end());
   binary.append(debug.begin(), debug.end());
   binary.append(names.begin(), names.end());
   binary.append(decorations.begin(), decorations.end());
   binary.append(typesGlobalValues.begin(), typesGlobalValues.end());
   binary.append(functions.begin(), functions.end());
 }
 
 #ifndef NDEBUG
 void Serializer::printValueIDMap(raw_ostream &os) {
   os << "\n= Value <id> Map =\n\n";
   for (auto valueIDPair : valueIDMap) {
     Value val = valueIDPair.first;
     os << "  " << val << " "
        << "id = " << valueIDPair.second << ' ';
     if (auto *op = val.getDefiningOp()) {
       os << "from op '" << op->getName() << "'";
     } else if (auto arg = val.dyn_cast<BlockArgument>()) {
       Block *block = arg.getOwner();
       os << "from argument of block " << block << ' ';
       os << " in op '" << block->getParentOp()->getName() << "'";
     }
     os << '\n';
   }
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // Module structure
 //===----------------------------------------------------------------------===//
 
 uint32_t Serializer::getOrCreateFunctionID(StringRef fnName) {
   auto funcID = funcIDMap.lookup(fnName);
   if (!funcID) {
     funcID = getNextID();
     funcIDMap[fnName] = funcID;
   }
   return funcID;
 }
 
 void Serializer::processCapability() {
   for (auto cap : module.vce_triple()->getCapabilities())
     encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
                           {static_cast<uint32_t>(cap)});
 }
 
 void Serializer::processDebugInfo() {
   if (!emitDebugInfo)
     return;
   auto fileLoc = module.getLoc().dyn_cast<FileLineColLoc>();
   auto fileName = fileLoc ? fileLoc.getFilename() : "<unknown>";
   fileID = getNextID();
   SmallVector<uint32_t, 16> operands;
   operands.push_back(fileID);
   spirv::encodeStringLiteralInto(operands, fileName);
   encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
   // TODO: Encode more debug instructions.
 }
 
 void Serializer::processExtension() {
   llvm::SmallVector<uint32_t, 16> extName;
   for (spirv::Extension ext : module.vce_triple()->getExtensions()) {
     extName.clear();
     spirv::encodeStringLiteralInto(extName, spirv::stringifyExtension(ext));
     encodeInstructionInto(extensions, spirv::Opcode::OpExtension, extName);
   }
 }
 
 void Serializer::processMemoryModel() {
   uint32_t mm = module->getAttrOfType<IntegerAttr>("memory_model").getInt();
   uint32_t am = module->getAttrOfType<IntegerAttr>("addressing_model").getInt();
 
   encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel, {am, mm});
 }
 
 LogicalResult Serializer::processConstantOp(spirv::ConstantOp op) {
   if (auto resultID = prepareConstant(op.getLoc(), op.getType(), op.value())) {
     valueIDMap[op.getResult()] = resultID;
     return success();
   }
   return failure();
 }
 
 LogicalResult Serializer::processSpecConstantOp(spirv::SpecConstantOp op) {
   if (auto resultID = prepareConstantScalar(op.getLoc(), op.default_value(),
                                             /*isSpec=*/true)) {
     // Emit the OpDecorate instruction for SpecId.
     if (auto specID = op->getAttrOfType<IntegerAttr>("spec_id")) {
       auto val = static_cast<uint32_t>(specID.getInt());
       emitDecoration(resultID, spirv::Decoration::SpecId, {val});
     }
 
     specConstIDMap[op.sym_name()] = resultID;
     return processName(resultID, op.sym_name());
   }
   return failure();
 }
 
 LogicalResult
 Serializer::processSpecConstantCompositeOp(spirv::SpecConstantCompositeOp op) {
   uint32_t typeID = 0;
   if (failed(processType(op.getLoc(), op.type(), typeID))) {
     return failure();
   }
 
   auto resultID = getNextID();
 
   SmallVector<uint32_t, 8> operands;
   operands.push_back(typeID);
   operands.push_back(resultID);
 
   auto constituents = op.constituents();
 
   for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
     auto constituent = constituents[index].dyn_cast<FlatSymbolRefAttr>();
 
     auto constituentName = constituent.getValue();
     auto constituentID = getSpecConstID(constituentName);
 
     if (!constituentID) {
       return op.emitError("unknown result <id> for specialization constant ")
              << constituentName;
     }
 
     operands.push_back(constituentID);
   }
 
   encodeInstructionInto(typesGlobalValues,
                         spirv::Opcode::OpSpecConstantComposite, operands);
   specConstIDMap[op.sym_name()] = resultID;
 
   return processName(resultID, op.sym_name());
 }
 
 LogicalResult Serializer::processUndefOp(spirv::UndefOp op) {
   auto undefType = op.getType();
   auto &id = undefValIDMap[undefType];
   if (!id) {
     id = getNextID();
     uint32_t typeID = 0;
     if (failed(processType(op.getLoc(), undefType, typeID)) ||
         failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpUndef,
                                      {typeID, id}))) {
       return failure();
     }
   }
   valueIDMap[op.getResult()] = id;
   return success();
 }
 
 LogicalResult Serializer::processDecoration(Location loc, uint32_t resultID,
                                             NamedAttribute attr) {
   auto attrName = attr.first.strref();
   auto decorationName = llvm::convertToCamelFromSnakeCase(attrName, true);
   auto decoration = spirv::symbolizeDecoration(decorationName);
   if (!decoration) {
     return emitError(
                loc, "non-argument attributes expected to have snake-case-ified "
                     "decoration name, unhandled attribute with name : ")
            << attrName;
   }
   SmallVector<uint32_t, 1> args;
   switch (decoration.getValue()) {
   case spirv::Decoration::Binding:
   case spirv::Decoration::DescriptorSet:
   case spirv::Decoration::Location:
     if (auto intAttr = attr.second.dyn_cast<IntegerAttr>()) {
       args.push_back(intAttr.getValue().getZExtValue());
       break;
     }
     return emitError(loc, "expected integer attribute for ") << attrName;
   case spirv::Decoration::BuiltIn:
     if (auto strAttr = attr.second.dyn_cast<StringAttr>()) {
       auto enumVal = spirv::symbolizeBuiltIn(strAttr.getValue());
       if (enumVal) {
         args.push_back(static_cast<uint32_t>(enumVal.getValue()));
         break;
       }
       return emitError(loc, "invalid ")
              << attrName << " attribute " << strAttr.getValue();
     }
     return emitError(loc, "expected string attribute for ") << attrName;
   case spirv::Decoration::Aliased:
   case spirv::Decoration::Flat:
   case spirv::Decoration::NonReadable:
   case spirv::Decoration::NonWritable:
   case spirv::Decoration::NoPerspective:
   case spirv::Decoration::Restrict:
     // For unit attributes, the args list has no values so we do nothing
     if (auto unitAttr = attr.second.dyn_cast<UnitAttr>())
       break;
     return emitError(loc, "expected unit attribute for ") << attrName;
   default:
     return emitError(loc, "unhandled decoration ") << decorationName;
   }
   return emitDecoration(resultID, decoration.getValue(), args);
 }
 
 LogicalResult Serializer::processName(uint32_t resultID, StringRef name) {
   assert(!name.empty() && "unexpected empty string for OpName");
 
   SmallVector<uint32_t, 4> nameOperands;
   nameOperands.push_back(resultID);
   if (failed(spirv::encodeStringLiteralInto(nameOperands, name))) {
     return failure();
   }
   return encodeInstructionInto(names, spirv::Opcode::OpName, nameOperands);
 }
 
 namespace {
 template <>
 LogicalResult Serializer::processTypeDecoration<spirv::ArrayType>(
     Location loc, spirv::ArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
   }
   return success();
 }
 
 template <>
 LogicalResult Serializer::processTypeDecoration<spirv::RuntimeArrayType>(
     Location Loc, spirv::RuntimeArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
   }
   return success();
 }
 
 LogicalResult Serializer::processMemberDecoration(
     uint32_t structID,
     const spirv::StructType::MemberDecorationInfo &memberDecoration) {
   SmallVector<uint32_t, 4> args(
       {structID, memberDecoration.memberIndex,
        static_cast<uint32_t>(memberDecoration.decoration)});
   if (memberDecoration.hasValue) {
     args.push_back(memberDecoration.decorationValue);
   }
   return encodeInstructionInto(decorations, spirv::Opcode::OpMemberDecorate,
                                args);
 }
 } // namespace
 
 LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
   LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n");
   assert(functionHeader.empty() && functionBody.empty());
 
   uint32_t fnTypeID = 0;
   // Generate type of the function.
   processType(op.getLoc(), op.getType(), fnTypeID);
 
   // Add the function definition.
   SmallVector<uint32_t, 4> operands;
   uint32_t resTypeID = 0;
   auto resultTypes = op.getType().getResults();
   if (resultTypes.size() > 1) {
     return op.emitError("cannot serialize function with multiple return types");
   }
   if (failed(processType(op.getLoc(),
                          (resultTypes.empty() ? getVoidType() : resultTypes[0]),
                          resTypeID))) {
     return failure();
   }
   operands.push_back(resTypeID);
   auto funcID = getOrCreateFunctionID(op.getName());
   operands.push_back(funcID);
   operands.push_back(static_cast<uint32_t>(op.function_control()));
   operands.push_back(fnTypeID);
   encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction, operands);
 
   // Add function name.
   if (failed(processName(funcID, op.getName()))) {
     return failure();
   }
 
   // Declare the parameters.
   for (auto arg : op.getArguments()) {
     uint32_t argTypeID = 0;
     if (failed(processType(op.getLoc(), arg.getType(), argTypeID))) {
       return failure();
     }
     auto argValueID = getNextID();
     valueIDMap[arg] = argValueID;
     encodeInstructionInto(functionHeader, spirv::Opcode::OpFunctionParameter,
                           {argTypeID, argValueID});
   }
 
   // Process the body.
   if (op.isExternal()) {
     return op.emitError("external function is unhandled");
   }
 
   // Some instructions (e.g., OpVariable) in a function must be in the first
   // block in the function. These instructions will be put in functionHeader.
   // Thus, we put the label in functionHeader first, and omit it from the first
   // block.
   encodeInstructionInto(functionHeader, spirv::Opcode::OpLabel,
                         {getOrCreateBlockID(&op.front())});
   processBlock(&op.front(), /*omitLabel=*/true);
   if (failed(visitInPrettyBlockOrder(
           &op.front(), [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true))) {
     return failure();
   }
 
   // There might be OpPhi instructions who have value references needing to fix.
   for (auto deferredValue : deferredPhiValues) {
     Value value = deferredValue.first;
     uint32_t id = getValueID(value);
     LLVM_DEBUG(llvm::dbgs() << "[phi] fix reference of value " << value
                             << " to id = " << id << '\n');
     assert(id && "OpPhi references undefined value!");
     for (size_t offset : deferredValue.second)
       functionBody[offset] = id;
   }
   deferredPhiValues.clear();
 
   LLVM_DEBUG(llvm::dbgs() << "-- completed function '" << op.getName()
                           << "' --\n");
   // Insert OpFunctionEnd.
   if (failed(encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionEnd,
                                    {}))) {
     return failure();
   }
 
   functions.append(functionHeader.begin(), functionHeader.end());
   functions.append(functionBody.begin(), functionBody.end());
   functionHeader.clear();
   functionBody.clear();
 
   return success();
 }
 
 LogicalResult Serializer::processVariableOp(spirv::VariableOp op) {
   SmallVector<uint32_t, 4> operands;
   SmallVector<StringRef, 2> elidedAttrs;
   uint32_t resultID = 0;
   uint32_t resultTypeID = 0;
   if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
     return failure();
   }
   operands.push_back(resultTypeID);
   resultID = getNextID();
   valueIDMap[op.getResult()] = resultID;
   operands.push_back(resultID);
   auto attr = op->getAttr(spirv::attributeName<spirv::StorageClass>());
   if (attr) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
   for (auto arg : op.getODSOperands(0)) {
     auto argID = getValueID(arg);
     if (!argID) {
       return emitError(op.getLoc(), "operand 0 has a use before def");
     }
     operands.push_back(argID);
   }
   emitDebugLine(functionHeader, op.getLoc());
   encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable, operands);
   for (auto attr : op->getAttrs()) {
     if (llvm::any_of(elidedAttrs,
                      [&](StringRef elided) { return attr.first == elided; })) {
       continue;
     }
     if (failed(processDecoration(op.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }
 
 LogicalResult
 Serializer::processGlobalVariableOp(spirv::GlobalVariableOp varOp) {
   // Get TypeID.
   uint32_t resultTypeID = 0;
   SmallVector<StringRef, 4> elidedAttrs;
   if (failed(processType(varOp.getLoc(), varOp.type(), resultTypeID))) {
     return failure();
   }
 
   if (isInterfaceStructPtrType(varOp.type())) {
     auto structType = varOp.type()
                           .cast<spirv::PointerType>()
                           .getPointeeType()
                           .cast<spirv::StructType>();
     if (failed(
             emitDecoration(getTypeID(structType), spirv::Decoration::Block))) {
       return varOp.emitError("cannot decorate ")
              << structType << " with Block decoration";
     }
   }
 
   elidedAttrs.push_back("type");
   SmallVector<uint32_t, 4> operands;
   operands.push_back(resultTypeID);
   auto resultID = getNextID();
 
   // Encode the name.
   auto varName = varOp.sym_name();
   elidedAttrs.push_back(SymbolTable::getSymbolAttrName());
   if (failed(processName(resultID, varName))) {
     return failure();
   }
   globalVarIDMap[varName] = resultID;
   operands.push_back(resultID);
 
   // Encode StorageClass.
   operands.push_back(static_cast<uint32_t>(varOp.storageClass()));
 
   // Encode initialization.
   if (auto initializer = varOp.initializer()) {
     auto initializerID = getVariableID(initializer.getValue());
     if (!initializerID) {
       return emitError(varOp.getLoc(),
                        "invalid usage of undefined variable as initializer");
     }
     operands.push_back(initializerID);
     elidedAttrs.push_back("initializer");
   }
 
   emitDebugLine(typesGlobalValues, varOp.getLoc());
   if (failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable,
                                    operands))) {
     elidedAttrs.push_back("initializer");
     return failure();
   }
 
   // Encode decorations.
   for (auto attr : varOp->getAttrs()) {
     if (llvm::any_of(elidedAttrs,
                      [&](StringRef elided) { return attr.first == elided; })) {
       continue;
     }
     if (failed(processDecoration(varOp.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
 // According to the SPIR-V spec "Validation Rules for Shader Capabilities":
 // "Composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
 // PushConstant Storage Classes must be explicitly laid out."
 bool Serializer::isInterfaceStructPtrType(Type type) const {
   if (auto ptrType = type.dyn_cast<spirv::PointerType>()) {
     switch (ptrType.getStorageClass()) {
     case spirv::StorageClass::PhysicalStorageBuffer:
     case spirv::StorageClass::PushConstant:
     case spirv::StorageClass::StorageBuffer:
     case spirv::StorageClass::Uniform:
       return ptrType.getPointeeType().isa<spirv::StructType>();
     default:
       break;
     }
   }
   return false;
 }
 
 LogicalResult Serializer::processType(Location loc, Type type,
                                       uint32_t &typeID) {
   // Maintains a set of names for nested identified struct types. This is used
   // to properly serialize recursive references.
   llvm::SetVector<StringRef> serializationCtx;
   return processTypeImpl(loc, type, typeID, serializationCtx);
 }
 
 LogicalResult
 Serializer::processTypeImpl(Location loc, Type type, uint32_t &typeID,
                             llvm::SetVector<StringRef> &serializationCtx) {
   typeID = getTypeID(type);
   if (typeID) {
     return success();
   }
   typeID = getNextID();
   SmallVector<uint32_t, 4> operands;
 
   operands.push_back(typeID);
   auto typeEnum = spirv::Opcode::OpTypeVoid;
   bool deferSerialization = false;
 
   if ((type.isa<FunctionType>() &&
        succeeded(prepareFunctionType(loc, type.cast<FunctionType>(), typeEnum,
                                      operands))) ||
       succeeded(prepareBasicType(loc, type, typeID, typeEnum, operands,
                                  deferSerialization, serializationCtx))) {
     if (deferSerialization)
       return success();
 
     typeIDMap[type] = typeID;
 
     if (failed(encodeInstructionInto(typesGlobalValues, typeEnum, operands)))
       return failure();
 
     if (recursiveStructInfos.count(type) != 0) {
       // This recursive struct type is emitted already, now the OpTypePointer
       // instructions referring to recursive references are emitted as well.
       for (auto &ptrInfo : recursiveStructInfos[type]) {
         // TODO: This might not work if more than 1 recursive reference is
         // present in the struct.
         SmallVector<uint32_t, 4> ptrOperands;
         ptrOperands.push_back(ptrInfo.pointerTypeID);
         ptrOperands.push_back(static_cast<uint32_t>(ptrInfo.storageClass));
         ptrOperands.push_back(typeIDMap[type]);
 
         if (failed(encodeInstructionInto(
                 typesGlobalValues, spirv::Opcode::OpTypePointer, ptrOperands)))
           return failure();
       }
 
       recursiveStructInfos[type].clear();
     }
 
     return success();
   }
 
   return failure();
 }
 
 LogicalResult Serializer::prepareBasicType(
     Location loc, Type type, uint32_t resultID, spirv::Opcode &typeEnum,
     SmallVectorImpl<uint32_t> &operands, bool &deferSerialization,
     llvm::SetVector<StringRef> &serializationCtx) {
   deferSerialization = false;
 
   if (isVoidType(type)) {
     typeEnum = spirv::Opcode::OpTypeVoid;
     return success();
   }
 
   if (auto intType = type.dyn_cast<IntegerType>()) {
     if (intType.getWidth() == 1) {
       typeEnum = spirv::Opcode::OpTypeBool;
       return success();
     }
 
     typeEnum = spirv::Opcode::OpTypeInt;
     operands.push_back(intType.getWidth());
     // SPIR-V OpTypeInt "Signedness specifies whether there are signed semantics
     // to preserve or validate.
     // 0 indicates unsigned, or no signedness semantics
     // 1 indicates signed semantics."
     operands.push_back(intType.isSigned() ? 1 : 0);
     return success();
   }
 
   if (auto floatType = type.dyn_cast<FloatType>()) {
     typeEnum = spirv::Opcode::OpTypeFloat;
     operands.push_back(floatType.getWidth());
     return success();
   }
 
   if (auto vectorType = type.dyn_cast<VectorType>()) {
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, vectorType.getElementType(), elementTypeID,
                                serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeVector;
     operands.push_back(elementTypeID);
     operands.push_back(vectorType.getNumElements());
     return success();
   }
 
   if (auto arrayType = type.dyn_cast<spirv::ArrayType>()) {
     typeEnum = spirv::Opcode::OpTypeArray;
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, arrayType.getElementType(), elementTypeID,
                                serializationCtx))) {
       return failure();
     }
     operands.push_back(elementTypeID);
     if (auto elementCountID = prepareConstantInt(
             loc, mlirBuilder.getI32IntegerAttr(arrayType.getNumElements()))) {
       operands.push_back(elementCountID);
     }
     return processTypeDecoration(loc, arrayType, resultID);
   }
 
   if (auto ptrType = type.dyn_cast<spirv::PointerType>()) {
     uint32_t pointeeTypeID = 0;
     spirv::StructType pointeeStruct =
         ptrType.getPointeeType().dyn_cast<spirv::StructType>();
 
     if (pointeeStruct && pointeeStruct.isIdentified() &&
         serializationCtx.count(pointeeStruct.getIdentifier()) != 0) {
       // A recursive reference to an enclosing struct is found.
       //
       // 1. Prepare an OpTypeForwardPointer with resultID and the ptr storage
       // class as operands.
       SmallVector<uint32_t, 2> forwardPtrOperands;
       forwardPtrOperands.push_back(resultID);
       forwardPtrOperands.push_back(
           static_cast<uint32_t>(ptrType.getStorageClass()));
 
       encodeInstructionInto(typesGlobalValues,
                             spirv::Opcode::OpTypeForwardPointer,
                             forwardPtrOperands);
 
       // 2. Find the pointee (enclosing) struct.
       auto structType = spirv::StructType::getIdentified(
           module.getContext(), pointeeStruct.getIdentifier());
 
       if (!structType)
         return failure();
 
       // 3. Mark the OpTypePointer that is supposed to be emitted by this call
       // as deferred.
       deferSerialization = true;
 
       // 4. Record the info needed to emit the deferred OpTypePointer
       // instruction when the enclosing struct is completely serialized.
       recursiveStructInfos[structType].push_back(
           {resultID, ptrType.getStorageClass()});
     } else {
       if (failed(processTypeImpl(loc, ptrType.getPointeeType(), pointeeTypeID,
                                  serializationCtx)))
         return failure();
     }
 
     typeEnum = spirv::Opcode::OpTypePointer;
     operands.push_back(static_cast<uint32_t>(ptrType.getStorageClass()));
     operands.push_back(pointeeTypeID);
     return success();
   }
 
   if (auto runtimeArrayType = type.dyn_cast<spirv::RuntimeArrayType>()) {
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, runtimeArrayType.getElementType(),
                                elementTypeID, serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeRuntimeArray;
     operands.push_back(elementTypeID);
     return processTypeDecoration(loc, runtimeArrayType, resultID);
   }
 
   if (auto structType = type.dyn_cast<spirv::StructType>()) {
     if (structType.isIdentified()) {
       processName(resultID, structType.getIdentifier());
       serializationCtx.insert(structType.getIdentifier());
     }
 
     bool hasOffset = structType.hasOffset();
     for (auto elementIndex :
          llvm::seq<uint32_t>(0, structType.getNumElements())) {
       uint32_t elementTypeID = 0;
       if (failed(processTypeImpl(loc, structType.getElementType(elementIndex),
                                  elementTypeID, serializationCtx))) {
         return failure();
       }
       operands.push_back(elementTypeID);
       if (hasOffset) {
         // Decorate each struct member with an offset
         spirv::StructType::MemberDecorationInfo offsetDecoration{
             elementIndex, /*hasValue=*/1, spirv::Decoration::Offset,
             static_cast<uint32_t>(structType.getMemberOffset(elementIndex))};
         if (failed(processMemberDecoration(resultID, offsetDecoration))) {
           return emitError(loc, "cannot decorate ")
                  << elementIndex << "-th member of " << structType
                  << " with its offset";
         }
       }
     }
     SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
     structType.getMemberDecorations(memberDecorations);
 
     for (auto &memberDecoration : memberDecorations) {
       if (failed(processMemberDecoration(resultID, memberDecoration))) {
         return emitError(loc, "cannot decorate ")
                << static_cast<uint32_t>(memberDecoration.memberIndex)
                << "-th member of " << structType << " with "
                << stringifyDecoration(memberDecoration.decoration);
       }
     }
 
     typeEnum = spirv::Opcode::OpTypeStruct;
 
     if (structType.isIdentified())
       serializationCtx.remove(structType.getIdentifier());
 
     return success();
   }
 
   if (auto cooperativeMatrixType =
           type.dyn_cast<spirv::CooperativeMatrixNVType>()) {
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, cooperativeMatrixType.getElementType(),
                                elementTypeID, serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeCooperativeMatrixNV;
     auto getConstantOp = [&](uint32_t id) {
       auto attr = IntegerAttr::get(IntegerType::get(type.getContext(), 32), id);
       return prepareConstantInt(loc, attr);
     };
     operands.push_back(elementTypeID);
     operands.push_back(
         getConstantOp(static_cast<uint32_t>(cooperativeMatrixType.getScope())));
     operands.push_back(getConstantOp(cooperativeMatrixType.getRows()));
     operands.push_back(getConstantOp(cooperativeMatrixType.getColumns()));
     return success();
   }
 
   if (auto matrixType = type.dyn_cast<spirv::MatrixType>()) {
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, matrixType.getColumnType(), elementTypeID,
                                serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeMatrix;
     operands.push_back(elementTypeID);
     operands.push_back(matrixType.getNumColumns());
     return success();
   }
 
   // TODO: Handle other types.
   return emitError(loc, "unhandled type in serialization: ") << type;
 }
 
 LogicalResult
 Serializer::prepareFunctionType(Location loc, FunctionType type,
                                 spirv::Opcode &typeEnum,
                                 SmallVectorImpl<uint32_t> &operands) {
   typeEnum = spirv::Opcode::OpTypeFunction;
   assert(type.getNumResults() <= 1 &&
          "serialization supports only a single return value");
   uint32_t resultID = 0;
   if (failed(processType(
           loc, type.getNumResults() == 1 ? type.getResult(0) : getVoidType(),
           resultID))) {
     return failure();
   }
   operands.push_back(resultID);
   for (auto &res : type.getInputs()) {
     uint32_t argTypeID = 0;
     if (failed(processType(loc, res, argTypeID))) {
       return failure();
     }
     operands.push_back(argTypeID);
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Constant
 //===----------------------------------------------------------------------===//
 
 uint32_t Serializer::prepareConstant(Location loc, Type constType,
                                      Attribute valueAttr) {
   if (auto id = prepareConstantScalar(loc, valueAttr)) {
     return id;
   }
 
   // This is a composite literal. We need to handle each component separately
   // and then emit an OpConstantComposite for the whole.
 
   if (auto id = getConstantID(valueAttr)) {
     return id;
   }
 
   uint32_t typeID = 0;
   if (failed(processType(loc, constType, typeID))) {
     return 0;
   }
 
   uint32_t resultID = 0;
   if (auto attr = valueAttr.dyn_cast<DenseElementsAttr>()) {
     int rank = attr.getType().dyn_cast<ShapedType>().getRank();
     SmallVector<uint64_t, 4> index(rank);
     resultID = prepareDenseElementsConstant(loc, constType, attr,
                                             /*dim=*/0, index);
   } else if (auto arrayAttr = valueAttr.dyn_cast<ArrayAttr>()) {
     resultID = prepareArrayConstant(loc, constType, arrayAttr);
   }
 
   if (resultID == 0) {
     emitError(loc, "cannot serialize attribute: ") << valueAttr;
     return 0;
   }
 
   constIDMap[valueAttr] = resultID;
   return resultID;
 }
 
 uint32_t Serializer::prepareArrayConstant(Location loc, Type constType,
                                           ArrayAttr attr) {
   uint32_t typeID = 0;
   if (failed(processType(loc, constType, typeID))) {
     return 0;
   }
 
   uint32_t resultID = getNextID();
   SmallVector<uint32_t, 4> operands = {typeID, resultID};
   operands.reserve(attr.size() + 2);
   auto elementType = constType.cast<spirv::ArrayType>().getElementType();
   for (Attribute elementAttr : attr) {
     if (auto elementID = prepareConstant(loc, elementType, elementAttr)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
   encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 // TODO: Turn the below function into iterative function, instead of
 // recursive function.
 uint32_t
 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
                                          DenseElementsAttr valueAttr, int dim,
                                          MutableArrayRef<uint64_t> index) {
   auto shapedType = valueAttr.getType().dyn_cast<ShapedType>();
   assert(dim <= shapedType.getRank());
   if (shapedType.getRank() == dim) {
     if (auto attr = valueAttr.dyn_cast<DenseIntElementsAttr>()) {
       return attr.getType().getElementType().isInteger(1)
                  ? prepareConstantBool(loc, attr.getValue<BoolAttr>(index))
                  : prepareConstantInt(loc, attr.getValue<IntegerAttr>(index));
     }
     if (auto attr = valueAttr.dyn_cast<DenseFPElementsAttr>()) {
       return prepareConstantFp(loc, attr.getValue<FloatAttr>(index));
     }
     return 0;
   }
 
   uint32_t typeID = 0;
   if (failed(processType(loc, constType, typeID))) {
     return 0;
   }
 
   uint32_t resultID = getNextID();
   SmallVector<uint32_t, 4> operands = {typeID, resultID};
   operands.reserve(shapedType.getDimSize(dim) + 2);
   auto elementType = constType.cast<spirv::CompositeType>().getElementType(0);
   for (int i = 0; i < shapedType.getDimSize(dim); ++i) {
     index[dim] = i;
     if (auto elementID = prepareDenseElementsConstant(
             loc, elementType, valueAttr, dim + 1, index)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
   encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantScalar(Location loc, Attribute valueAttr,
                                            bool isSpec) {
   if (auto floatAttr = valueAttr.dyn_cast<FloatAttr>()) {
     return prepareConstantFp(loc, floatAttr, isSpec);
   }
   if (auto boolAttr = valueAttr.dyn_cast<BoolAttr>()) {
     return prepareConstantBool(loc, boolAttr, isSpec);
   }
   if (auto intAttr = valueAttr.dyn_cast<IntegerAttr>()) {
     return prepareConstantInt(loc, intAttr, isSpec);
   }
 
   return 0;
 }
 
 uint32_t Serializer::prepareConstantBool(Location loc, BoolAttr boolAttr,
                                          bool isSpec) {
   if (!isSpec) {
     // We can de-duplicate normal constants, but not specialization constants.
     if (auto id = getConstantID(boolAttr)) {
       return id;
     }
   }
 
   // Process the type for this bool literal
   uint32_t typeID = 0;
   if (failed(processType(loc, boolAttr.getType(), typeID))) {
     return 0;
   }
 
   auto resultID = getNextID();
   auto opcode = boolAttr.getValue()
                     ? (isSpec ? spirv::Opcode::OpSpecConstantTrue
                               : spirv::Opcode::OpConstantTrue)
                     : (isSpec ? spirv::Opcode::OpSpecConstantFalse
                               : spirv::Opcode::OpConstantFalse);
   encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID});
 
   if (!isSpec) {
     constIDMap[boolAttr] = resultID;
   }
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
                                         bool isSpec) {
   if (!isSpec) {
     // We can de-duplicate normal constants, but not specialization constants.
     if (auto id = getConstantID(intAttr)) {
       return id;
     }
   }
 
   // Process the type for this integer literal
   uint32_t typeID = 0;
   if (failed(processType(loc, intAttr.getType(), typeID))) {
     return 0;
   }
 
   auto resultID = getNextID();
   APInt value = intAttr.getValue();
   unsigned bitwidth = value.getBitWidth();
   bool isSigned = value.isSignedIntN(bitwidth);
 
   auto opcode =
       isSpec ? spirv::Opcode::OpSpecConstant : spirv::Opcode::OpConstant;
 
   // According to SPIR-V spec, "When the type's bit width is less than 32-bits,
   // the literal's value appears in the low-order bits of the word, and the
   // high-order bits must be 0 for a floating-point type, or 0 for an integer
   // type with Signedness of 0, or sign extended when Signedness is 1."
   if (bitwidth == 32 || bitwidth == 16) {
     uint32_t word = 0;
     if (isSigned) {
       word = static_cast<int32_t>(value.getSExtValue());
     } else {
       word = static_cast<uint32_t>(value.getZExtValue());
     }
     encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   }
   // According to SPIR-V spec: "When the type's bit width is larger than one
   // word, the literal’s low-order words appear first."
   else if (bitwidth == 64) {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words;
     if (isSigned) {
       words = llvm::bit_cast<DoubleWord>(value.getSExtValue());
     } else {
       words = llvm::bit_cast<DoubleWord>(value.getZExtValue());
     }
     encodeInstructionInto(typesGlobalValues, opcode,
                           {typeID, resultID, words.word1, words.word2});
   } else {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss, /*isSigned=*/false);
 
     emitError(loc, "cannot serialize ")
         << bitwidth << "-bit integer literal: " << rss.str();
     return 0;
   }
 
   if (!isSpec) {
     constIDMap[intAttr] = resultID;
   }
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantFp(Location loc, FloatAttr floatAttr,
                                        bool isSpec) {
   if (!isSpec) {
     // We can de-duplicate normal constants, but not specialization constants.
     if (auto id = getConstantID(floatAttr)) {
       return id;
     }
   }
 
   // Process the type for this float literal
   uint32_t typeID = 0;
   if (failed(processType(loc, floatAttr.getType(), typeID))) {
     return 0;
   }
 
   auto resultID = getNextID();
   APFloat value = floatAttr.getValue();
   APInt intValue = value.bitcastToAPInt();
 
   auto opcode =
       isSpec ? spirv::Opcode::OpSpecConstant : spirv::Opcode::OpConstant;
 
   if (&value.getSemantics() == &APFloat::IEEEsingle()) {
     uint32_t word = llvm::bit_cast<uint32_t>(value.convertToFloat());
     encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   } else if (&value.getSemantics() == &APFloat::IEEEdouble()) {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words = llvm::bit_cast<DoubleWord>(value.convertToDouble());
     encodeInstructionInto(typesGlobalValues, opcode,
                           {typeID, resultID, words.word1, words.word2});
   } else if (&value.getSemantics() == &APFloat::IEEEhalf()) {
     uint32_t word =
         static_cast<uint32_t>(value.bitcastToAPInt().getZExtValue());
     encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
   } else {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss);
 
     emitError(loc, "cannot serialize ")
         << floatAttr.getType() << "-typed float literal: " << rss.str();
     return 0;
   }
 
   if (!isSpec) {
     constIDMap[floatAttr] = resultID;
   }
   return resultID;
 }
 
 //===----------------------------------------------------------------------===//
 // Control flow
 //===----------------------------------------------------------------------===//
 
 uint32_t Serializer::getOrCreateBlockID(Block *block) {
   if (uint32_t id = getBlockID(block))
     return id;
   return blockIDMap[block] = getNextID();
 }
 
 LogicalResult
 Serializer::processBlock(Block *block, bool omitLabel,
                          function_ref<void()> actionBeforeTerminator) {
   LLVM_DEBUG(llvm::dbgs() << "processing block " << block << ":\n");
   LLVM_DEBUG(block->print(llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << '\n');
   if (!omitLabel) {
     uint32_t blockID = getOrCreateBlockID(block);
     LLVM_DEBUG(llvm::dbgs()
                << "[block] " << block << " (id = " << blockID << ")\n");
 
     // Emit OpLabel for this block.
     encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {blockID});
   }
 
   // Emit OpPhi instructions for block arguments, if any.
   if (failed(emitPhiForBlockArguments(block)))
     return failure();
 
   // Process each op in this block except the terminator.
   for (auto &op : llvm::make_range(block->begin(), std::prev(block->end()))) {
     if (failed(processOperation(&op)))
       return failure();
   }
 
   // Process the terminator.
   if (actionBeforeTerminator)
     actionBeforeTerminator();
   if (failed(processOperation(&block->back())))
     return failure();
 
   return success();
 }
 
 LogicalResult Serializer::emitPhiForBlockArguments(Block *block) {
   // Nothing to do if this block has no arguments or it's the entry block, which
   // always has the same arguments as the function signature.
   if (block->args_empty() || block->isEntryBlock())
     return success();
 
   // If the block has arguments, we need to create SPIR-V OpPhi instructions.
   // A SPIR-V OpPhi instruction is of the syntax:
   //   OpPhi | result type | result <id> | (value <id>, parent block <id>) pair
   // So we need to collect all predecessor blocks and the arguments they send
   // to this block.
   SmallVector<std::pair<Block *, Operation::operand_iterator>, 4> predecessors;
   for (Block *predecessor : block->getPredecessors()) {
     auto *terminator = predecessor->getTerminator();
     // The predecessor here is the immediate one according to MLIR's IR
     // structure. It does not directly map to the incoming parent block for the
     // OpPhi instructions at SPIR-V binary level. This is because structured
     // control flow ops are serialized to multiple SPIR-V blocks. If there is a
     // spv.selection/spv.loop op in the MLIR predecessor block, the branch op
     // jumping to the OpPhi's block then resides in the previous structured
     // control flow op's merge block.
     predecessor = getPhiIncomingBlock(predecessor);
     if (auto branchOp = dyn_cast<spirv::BranchOp>(terminator)) {
       predecessors.emplace_back(predecessor, branchOp.operand_begin());
     } else {
       return terminator->emitError("unimplemented terminator for Phi creation");
     }
   }
 
   // Then create OpPhi instruction for each of the block argument.
   for (auto argIndex : llvm::seq<unsigned>(0, block->getNumArguments())) {
     BlockArgument arg = block->getArgument(argIndex);
 
     // Get the type <id> and result <id> for this OpPhi instruction.
     uint32_t phiTypeID = 0;
     if (failed(processType(arg.getLoc(), arg.getType(), phiTypeID)))
       return failure();
     uint32_t phiID = getNextID();
 
     LLVM_DEBUG(llvm::dbgs() << "[phi] for block argument #" << argIndex << ' '
                             << arg << " (id = " << phiID << ")\n");
 
     // Prepare the (value <id>, parent block <id>) pairs.
     SmallVector<uint32_t, 8> phiArgs;
     phiArgs.push_back(phiTypeID);
     phiArgs.push_back(phiID);
 
     for (auto predIndex : llvm::seq<unsigned>(0, predecessors.size())) {
       Value value = *(predecessors[predIndex].second + argIndex);
       uint32_t predBlockId = getOrCreateBlockID(predecessors[predIndex].first);
       LLVM_DEBUG(llvm::dbgs() << "[phi] use predecessor (id = " << predBlockId
                               << ") value " << value << ' ');
       // Each pair is a value <id> ...
       uint32_t valueId = getValueID(value);
       if (valueId == 0) {
         // The op generating this value hasn't been visited yet so we don't have
         // an <id> assigned yet. Record this to fix up later.
         LLVM_DEBUG(llvm::dbgs() << "(need to fix)\n");
         deferredPhiValues[value].push_back(functionBody.size() + 1 +
                                            phiArgs.size());
       } else {
         LLVM_DEBUG(llvm::dbgs() << "(id = " << valueId << ")\n");
       }
       phiArgs.push_back(valueId);
       // ... and a parent block <id>.
       phiArgs.push_back(predBlockId);
     }
 
     encodeInstructionInto(functionBody, spirv::Opcode::OpPhi, phiArgs);
     valueIDMap[arg] = phiID;
   }
 
   return success();
 }
 
 LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   // Assign <id>s to all blocks so that branches inside the SelectionOp can
   // resolve properly.
   auto &body = selectionOp.body();
   for (Block &block : body)
     getOrCreateBlockID(&block);
 
   auto *headerBlock = selectionOp.getHeaderBlock();
   auto *mergeBlock = selectionOp.getMergeBlock();
   auto mergeID = getBlockID(mergeBlock);
   auto loc = selectionOp.getLoc();
 
   // Emit the selection header block, which dominates all other blocks, first.
   // We need to emit an OpSelectionMerge instruction before the selection header
   // block's terminator.
   auto emitSelectionMerge = [&]() {
     emitDebugLine(functionBody, loc);
     lastProcessedWasMergeInst = true;
     encodeInstructionInto(
         functionBody, spirv::Opcode::OpSelectionMerge,
         {mergeID, static_cast<uint32_t>(selectionOp.selection_control())});
   };
   // For structured selection, we cannot have blocks in the selection construct
   // branching to the selection header block. Entering the selection (and
   // reaching the selection header) must be from the block containing the
   // spv.selection op. If there are ops ahead of the spv.selection op in the
   // block, we can "merge" them into the selection header. So here we don't need
   // to emit a separate block; just continue with the existing block.
   if (failed(processBlock(headerBlock, /*omitLabel=*/true, emitSelectionMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The selection header block and merge block are skipped by this
   // visitor.
   if (failed(visitInPrettyBlockOrder(
           headerBlock, [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true, /*skipBlocks=*/{mergeBlock})))
     return failure();
 
   // There is nothing to do for the merge block in the selection, which just
   // contains a spv.mlir.merge op, itself. But we need to have an OpLabel
   // instruction to start a new SPIR-V block for ops following this SelectionOp.
   // The block should use the <id> for the merge block.
   return encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
 }
 
 LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   // Assign <id>s to all blocks so that branches inside the LoopOp can resolve
   // properly. We don't need to assign for the entry block, which is just for
   // satisfying MLIR region's structural requirement.
   auto &body = loopOp.body();
   for (Block &block :
        llvm::make_range(std::next(body.begin(), 1), body.end())) {
     getOrCreateBlockID(&block);
   }
   auto *headerBlock = loopOp.getHeaderBlock();
   auto *continueBlock = loopOp.getContinueBlock();
   auto *mergeBlock = loopOp.getMergeBlock();
   auto headerID = getBlockID(headerBlock);
   auto continueID = getBlockID(continueBlock);
   auto mergeID = getBlockID(mergeBlock);
   auto loc = loopOp.getLoc();
 
   // This LoopOp is in some MLIR block with preceding and following ops. In the
   // binary format, it should reside in separate SPIR-V blocks from its
   // preceding and following ops. So we need to emit unconditional branches to
   // jump to this LoopOp's SPIR-V blocks and jumping back to the normal flow
   // afterwards.
   encodeInstructionInto(functionBody, spirv::Opcode::OpBranch, {headerID});
 
   // LoopOp's entry block is just there for satisfying MLIR's structural
   // requirements so we omit it and start serialization from the loop header
   // block.
 
   // Emit the loop header block, which dominates all other blocks, first. We
   // need to emit an OpLoopMerge instruction before the loop header block's
   // terminator.
   auto emitLoopMerge = [&]() {
     emitDebugLine(functionBody, loc);
     lastProcessedWasMergeInst = true;
     encodeInstructionInto(
         functionBody, spirv::Opcode::OpLoopMerge,
         {mergeID, continueID, static_cast<uint32_t>(loopOp.loop_control())});
   };
   if (failed(processBlock(headerBlock, /*omitLabel=*/false, emitLoopMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The loop header block, loop continue block, and loop merge block are
   // skipped by this visitor and handled later in this function.
   if (failed(visitInPrettyBlockOrder(
           headerBlock, [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true, /*skipBlocks=*/{continueBlock, mergeBlock})))
     return failure();
 
   // We have handled all other blocks. Now get to the loop continue block.
   if (failed(processBlock(continueBlock)))
     return failure();
 
   // There is nothing to do for the merge block in the loop, which just contains
   // a spv.mlir.merge op, itself. But we need to have an OpLabel instruction to
   // start a new SPIR-V block for ops following this LoopOp. The block should
   // use the <id> for the merge block.
   return encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {mergeID});
 }
 
 LogicalResult Serializer::processBranchConditionalOp(
     spirv::BranchConditionalOp condBranchOp) {
   auto conditionID = getValueID(condBranchOp.condition());
   auto trueLabelID = getOrCreateBlockID(condBranchOp.getTrueBlock());
   auto falseLabelID = getOrCreateBlockID(condBranchOp.getFalseBlock());
   SmallVector<uint32_t, 5> arguments{conditionID, trueLabelID, falseLabelID};
 
   if (auto weights = condBranchOp.branch_weights()) {
     for (auto val : weights->getValue())
       arguments.push_back(val.cast<IntegerAttr>().getInt());
   }
 
   emitDebugLine(functionBody, condBranchOp.getLoc());
   return encodeInstructionInto(functionBody, spirv::Opcode::OpBranchConditional,
                                arguments);
 }
 
 LogicalResult Serializer::processBranchOp(spirv::BranchOp branchOp) {
   emitDebugLine(functionBody, branchOp.getLoc());
   return encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
                                {getOrCreateBlockID(branchOp.getTarget())});
 }
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
 LogicalResult Serializer::encodeExtensionInstruction(
     Operation *op, StringRef extensionSetName, uint32_t extensionOpcode,
     ArrayRef<uint32_t> operands) {
   // Check if the extension has been imported.
   auto &setID = extendedInstSetIDMap[extensionSetName];
   if (!setID) {
     setID = getNextID();
     SmallVector<uint32_t, 16> importOperands;
     importOperands.push_back(setID);
     if (failed(
             spirv::encodeStringLiteralInto(importOperands, extensionSetName)) ||
         failed(encodeInstructionInto(
             extendedSets, spirv::Opcode::OpExtInstImport, importOperands))) {
       return failure();
     }
   }
 
   // The first two operands are the result type <id> and result <id>. The set
   // <id> and the opcode need to be insert after this.
   if (operands.size() < 2) {
     return op->emitError("extended instructions must have a result encoding");
   }
   SmallVector<uint32_t, 8> extInstOperands;
   extInstOperands.reserve(operands.size() + 2);
   extInstOperands.append(operands.begin(), std::next(operands.begin(), 2));
   extInstOperands.push_back(setID);
   extInstOperands.push_back(extensionOpcode);
   extInstOperands.append(std::next(operands.begin(), 2), operands.end());
   return encodeInstructionInto(functionBody, spirv::Opcode::OpExtInst,
                                extInstOperands);
 }
 
 LogicalResult Serializer::processAddressOfOp(spirv::AddressOfOp addressOfOp) {
   auto varName = addressOfOp.variable();
   auto variableID = getVariableID(varName);
   if (!variableID) {
     return addressOfOp.emitError("unknown result <id> for variable ")
            << varName;
   }
   valueIDMap[addressOfOp.pointer()] = variableID;
   return success();
 }
 
 LogicalResult
 Serializer::processReferenceOfOp(spirv::ReferenceOfOp referenceOfOp) {
   auto constName = referenceOfOp.spec_const();
   auto constID = getSpecConstID(constName);
   if (!constID) {
     return referenceOfOp.emitError(
                "unknown result <id> for specialization constant ")
            << constName;
   }
   valueIDMap[referenceOfOp.reference()] = constID;
   return success();
 }
 
 LogicalResult Serializer::processOperation(Operation *opInst) {
   LLVM_DEBUG(llvm::dbgs() << "[op] '" << opInst->getName() << "'\n");
 
   // First dispatch the ops that do not directly mirror an instruction from
   // the SPIR-V spec.
   return TypeSwitch<Operation *, LogicalResult>(opInst)
       .Case([&](spirv::AddressOfOp op) { return processAddressOfOp(op); })
       .Case([&](spirv::BranchOp op) { return processBranchOp(op); })
       .Case([&](spirv::BranchConditionalOp op) {
         return processBranchConditionalOp(op);
       })
       .Case([&](spirv::ConstantOp op) { return processConstantOp(op); })
       .Case([&](spirv::FuncOp op) { return processFuncOp(op); })
       .Case([&](spirv::GlobalVariableOp op) {
         return processGlobalVariableOp(op);
       })
       .Case([&](spirv::LoopOp op) { return processLoopOp(op); })
       .Case([&](spirv::ModuleEndOp) { return success(); })
       .Case([&](spirv::ReferenceOfOp op) { return processReferenceOfOp(op); })
       .Case([&](spirv::SelectionOp op) { return processSelectionOp(op); })
       .Case([&](spirv::SpecConstantOp op) { return processSpecConstantOp(op); })
       .Case([&](spirv::SpecConstantCompositeOp op) {
         return processSpecConstantCompositeOp(op);
       })
       .Case([&](spirv::UndefOp op) { return processUndefOp(op); })
       .Case([&](spirv::VariableOp op) { return processVariableOp(op); })
 
       // Then handle all the ops that directly mirror SPIR-V instructions with
       // auto-generated methods.
       .Default(
           [&](Operation *op) { return dispatchToAutogenSerialization(op); });
 }
 
 LogicalResult Serializer::processOpWithoutGrammarAttr(Operation *op,
                                                       StringRef extInstSet,
                                                       uint32_t opcode) {
   SmallVector<uint32_t, 4> operands;
   Location loc = op->getLoc();
 
   uint32_t resultID = 0;
   if (op->getNumResults() != 0) {
     uint32_t resultTypeID = 0;
     if (failed(processType(loc, op->getResult(0).getType(), resultTypeID)))
       return failure();
     operands.push_back(resultTypeID);
 
     resultID = getNextID();
     operands.push_back(resultID);
     valueIDMap[op->getResult(0)] = resultID;
   };
 
   for (Value operand : op->getOperands())
     operands.push_back(getValueID(operand));
 
   emitDebugLine(functionBody, loc);
 
   if (extInstSet.empty()) {
     encodeInstructionInto(functionBody, static_cast<spirv::Opcode>(opcode),
                           operands);
   } else {
     encodeExtensionInstruction(op, extInstSet, opcode, operands);
   }
 
   if (op->getNumResults() != 0) {
     for (auto attr : op->getAttrs()) {
       if (failed(processDecoration(loc, resultID, attr)))
         return failure();
     }
   }
 
   return success();
 }
 
 namespace {
 template <>
 LogicalResult
 Serializer::processOp<spirv::EntryPointOp>(spirv::EntryPointOp op) {
   SmallVector<uint32_t, 4> operands;
   // Add the ExecutionModel.
   operands.push_back(static_cast<uint32_t>(op.execution_model()));
   // Add the function <id>.
   auto funcID = getFunctionID(op.fn());
   if (!funcID) {
     return op.emitError("missing <id> for function ")
            << op.fn()
            << "; function needs to be defined before spv.EntryPoint is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the name of the function.
   spirv::encodeStringLiteralInto(operands, op.fn());
 
   // Add the interface values.
   if (auto interface = op.interface()) {
     for (auto var : interface.getValue()) {
       auto id = getVariableID(var.cast<FlatSymbolRefAttr>().getValue());
       if (!id) {
         return op.emitError("referencing undefined global variable."
                             "spv.EntryPoint is at the end of spv.module. All "
                             "referenced variables should already be defined");
       }
       operands.push_back(id);
     }
   }
   return encodeInstructionInto(entryPoints, spirv::Opcode::OpEntryPoint,
                                operands);
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::ControlBarrierOp>(spirv::ControlBarrierOp op) {
   StringRef argNames[] = {"execution_scope", "memory_scope",
                           "memory_semantics"};
   SmallVector<uint32_t, 3> operands;
 
   for (auto argName : argNames) {
     auto argIntAttr = op->getAttrOfType<IntegerAttr>(argName);
     auto operand = prepareConstantInt(op.getLoc(), argIntAttr);
     if (!operand) {
       return failure();
     }
     operands.push_back(operand);
   }
 
   return encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrier,
                                operands);
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::ExecutionModeOp>(spirv::ExecutionModeOp op) {
   SmallVector<uint32_t, 4> operands;
   // Add the function <id>.
   auto funcID = getFunctionID(op.fn());
   if (!funcID) {
     return op.emitError("missing <id> for function ")
            << op.fn()
            << "; function needs to be serialized before ExecutionModeOp is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the ExecutionMode.
   operands.push_back(static_cast<uint32_t>(op.execution_mode()));
 
   // Serialize values if any.
   auto values = op.values();
   if (values) {
     for (auto &intVal : values.getValue()) {
       operands.push_back(static_cast<uint32_t>(
           intVal.cast<IntegerAttr>().getValue().getZExtValue()));
     }
   }
   return encodeInstructionInto(executionModes, spirv::Opcode::OpExecutionMode,
                                operands);
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::MemoryBarrierOp>(spirv::MemoryBarrierOp op) {
   StringRef argNames[] = {"memory_scope", "memory_semantics"};
   SmallVector<uint32_t, 2> operands;
 
   for (auto argName : argNames) {
     auto argIntAttr = op->getAttrOfType<IntegerAttr>(argName);
     auto operand = prepareConstantInt(op.getLoc(), argIntAttr);
     if (!operand) {
       return failure();
     }
     operands.push_back(operand);
   }
 
   return encodeInstructionInto(functionBody, spirv::Opcode::OpMemoryBarrier,
                                operands);
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::FunctionCallOp>(spirv::FunctionCallOp op) {
   auto funcName = op.callee();
   uint32_t resTypeID = 0;
 
   Type resultTy = op.getNumResults() ? *op.result_type_begin() : getVoidType();
   if (failed(processType(op.getLoc(), resultTy, resTypeID)))
     return failure();
 
   auto funcID = getOrCreateFunctionID(funcName);
   auto funcCallID = getNextID();
   SmallVector<uint32_t, 8> operands{resTypeID, funcCallID, funcID};
 
   for (auto value : op.arguments()) {
     auto valueID = getValueID(value);
     assert(valueID && "cannot find a value for spv.FunctionCall");
     operands.push_back(valueID);
   }
 
   if (!resultTy.isa<NoneType>())
     valueIDMap[op.getResult(0)] = funcCallID;
 
   return encodeInstructionInto(functionBody, spirv::Opcode::OpFunctionCall,
                                operands);
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   SmallVector<uint32_t, 4> operands;
   SmallVector<StringRef, 2> elidedAttrs;
 
   for (Value operand : op->getOperands()) {
     auto id = getValueID(operand);
     assert(id && "use before def!");
     operands.push_back(id);
   }
 
   if (auto attr = op->getAttr("memory_access")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("memory_access");
 
   if (auto attr = op->getAttr("alignment")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("alignment");
 
   if (auto attr = op->getAttr("source_memory_access")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("source_memory_access");
 
   if (auto attr = op->getAttr("source_alignment")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("source_alignment");
   emitDebugLine(functionBody, op.getLoc());
   encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands);
 
   return success();
 }
 
 // Pull in auto-generated Serializer::dispatchToAutogenSerialization() and
 // various Serializer::processOp<...>() specializations.
 #define GET_SERIALIZATION_FNS
 #include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
 } // namespace
 
 LogicalResult Serializer::emitDecoration(uint32_t target,
                                          spirv::Decoration decoration,
                                          ArrayRef<uint32_t> params) {
   uint32_t wordCount = 3 + params.size();
   decorations.push_back(
       spirv::getPrefixedOpcode(wordCount, spirv::Opcode::OpDecorate));
   decorations.push_back(target);
   decorations.push_back(static_cast<uint32_t>(decoration));
   decorations.append(params.begin(), params.end());
   return success();
 }
 
 LogicalResult Serializer::emitDebugLine(SmallVectorImpl<uint32_t> &binary,
                                         Location loc) {
   if (!emitDebugInfo)
     return success();
 
   if (lastProcessedWasMergeInst) {
     lastProcessedWasMergeInst = false;
     return success();
   }
 
   auto fileLoc = loc.dyn_cast<FileLineColLoc>();
   if (fileLoc)
     encodeInstructionInto(binary, spirv::Opcode::OpLine,
                           {fileID, fileLoc.getLine(), fileLoc.getColumn()});
   return success();
 }
 
 namespace mlir {
 LogicalResult spirv::serialize(spirv::ModuleOp module,
                                SmallVectorImpl<uint32_t> &binary,
                                bool emitDebugInfo) {
   if (!module.vce_triple().hasValue())
     return module.emitError(
         "module must have 'vce_triple' attribute to be serializeable");
 
   Serializer serializer(module, emitDebugInfo);
 
   if (failed(serializer.serialize()))
     return failure();
 
   LLVM_DEBUG(serializer.printValueIDMap(llvm::dbgs()));
 
   serializer.collect(binary);
   return success();
 }
 } // namespace mlir

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

static void emitDeserializationFunction(const Record *attrClass,
   os << "  return success();\n";
   os << "}\n\n";
 }
 
 /// Generates the prologue for the function that dispatches the deserialization
 /// based on the `opcode`.
 static void initDispatchDeserializationFn(StringRef opcode, StringRef words,
                                           raw_ostream &os) {
-  os << formatv(
-      "LogicalResult "
-      "Deserializer::dispatchToAutogenDeserialization(spirv::Opcode {0}, "
-      "ArrayRef<uint32_t> {1}) {{\n",
+  os << formatv("LogicalResult spirv::Deserializer::"
+                "dispatchToAutogenDeserialization(spirv::Opcode {0},"
+                " ArrayRef<uint32_t> {1}) {{\n",
                 opcode, words);
   os << formatv("  switch ({0}) {{\n", opcode);
 }
 
 /// Generates the body of the dispatch function, by generating the case label
 /// for an opcode and the call to the method to perform the deserialization.
 static void emitDeserializationDispatch(const Operator &op, const Record *def,
                                         StringRef tabs, StringRef words,
                                         raw_ostream &os) {
static void finalizeDispatchDeserializationFn(StringRef opcode,
   os << "  }\n";
   os << "}\n";
 }
 
 static void initExtendedSetDeserializationDispatch(StringRef extensionSetName,
                                                    StringRef instructionID,
                                                    StringRef words,
                                                    raw_ostream &os) {
-  os << formatv("LogicalResult "
-                "Deserializer::dispatchToExtensionSetAutogenDeserialization("
+  os << formatv("LogicalResult spirv::Deserializer::"
+                "dispatchToExtensionSetAutogenDeserialization("
                 "StringRef {0}, uint32_t {1}, ArrayRef<uint32_t> {2}) {{\n",
                 extensionSetName, instructionID, words);
 }
 
 static void
 emitExtendedSetDeserializationDispatch(const RecordKeeper &recordKeeper,
                                        raw_ostream &os) {
   StringRef extensionSetName("extensionSetName"),