[mlir][spirv] Use SingleBlock + NoTerminator for spv.module

[antiagainst]

Summary

This allows us to remove the spv.mlir.endmodule op and
all the code associated with it.

Along the way, tightened the APIs for spv.module a bit
by removing some aliases. Now we use getRegion to get
the only region, and getBody to get the region's only
block.

Depends On D103264

mlir/docs/Dialects/SPIR-V.md

*   Ops that directly mirror instructions in the specification have `CamelCase`
     SPIR-V instruction.
 *   Ops with `snake_case` names are those that have different representation
     from corresponding instructions (or concepts) in the specification. These
     ops are mostly for defining the SPIR-V structure. For example, `spv.module`
     and `spv.Constant`. They may correspond to one or more instructions during
     (de)serialization.
 *   Ops with `mlir.snake_case` names are those that have no corresponding
     instructions (or concepts) in the binary format. They are introduced to
-    satisfy MLIR structural requirements. For example, `spv.mlir.endmodule` and
-    `spv.mlir.merge`. They map to no instructions during (de)serialization.
+    satisfy MLIR structural requirements. For example, `spv.mlir.merge`. They
+    map to no instructions during (de)serialization.
 
 (TODO: consider merging the last two cases and adopting `spv.mlir.` prefix for
 them.)
 
 ## Module
 
 A SPIR-V module is defined via the `spv.module` op, which has one region that
 contains one block. Model-level instructions, including function definitions,

mlir/docs/SPIRVToLLVMDialectConversion.md

 
 *   Addressing model
 *   Memory model
 *   Version-Capability-Extension attribute
 
 `spv.module` is converted into `ModuleOp`. This plays a role of enclosing scope
 to LLVM ops. At the moment, SPIR-V module attributes are ignored.
 
-`spv.mlir.endmodule` is mapped to an equivalent terminator `ModuleTerminatorOp`.
-
 ## `mlir-spirv-cpu-runner`
 
 `mlir-spirv-cpu-runner` allows to execute `gpu` dialect kernel on the CPU via
 SPIR-V to LLVM dialect conversion. Currently, only single-threaded kernel is
 supported.
 
 To build the runner, add the following option to `cmake`:
 ```bash

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

::mlir::spirv::StorageClass storageClass() {
       return this->type().cast<::mlir::spirv::PointerType>().getStorageClass();
     }
   }];
 }
 
 // -----
 
 def SPV_ModuleOp : SPV_Op<"module",
-                          [IsolatedFromAbove,
-                           SingleBlockImplicitTerminator<"ModuleEndOp">,
-                           SymbolTable, Symbol]> {
+    [IsolatedFromAbove, NoRegionArguments, NoTerminator,
+     SingleBlock, SymbolTable, Symbol]> {
   let summary = "The top-level op that defines a SPIR-V module";
 
   let description = [{
     This op defines a SPIR-V module using a MLIR region. The region contains
     one block. Module-level operations, including functions definitions,
     are all placed in this block.
 
     Using an op with a region to define a SPIR-V module enables "embedding"
     SPIR-V modules in other dialects in a clean manner: this op guarantees
     the validity and serializability of a SPIR-V module and thus serves as
     a clear-cut boundary.
 
     This op takes no operands and generates no results. This op should not
     implicitly capture values from the enclosing environment.
 
     This op has only one region, which only contains one block. The block
-    must be terminated via the `spv.mlir.endmodule` op.
+    has no terminator.
 
     <!-- End of AutoGen section -->
 
     ```
     addressing-model ::= `Logical` | `Physical32` | `Physical64` | ...
     memory-model ::= `Simple` | `GLSL450` | `OpenCL` | `Vulkan` | ...
     spv-module-op ::= `spv.module` addressing-model memory-model
                       (requires  spirv-vce-attribute)?
let arguments = (ins
     SPV_AddressingModelAttr:$addressing_model,
     SPV_MemoryModelAttr:$memory_model,
     OptionalAttr<SPV_VerCapExtAttr>:$vce_triple,
     OptionalAttr<StrAttr>:$sym_name
   );
 
   let results = (outs);
 
-  let regions = (region SizedRegion<1>:$body);
+  let regions = (region AnyRegion);
 
   let builders = [
     OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name)>,
     OpBuilder<(ins "spirv::AddressingModel":$addressing_model,
       "spirv::MemoryModel":$memory_model,
       CArg<"Optional<StringRef>", "llvm::None">:$name)>
   ];
 
   // We need to ensure the block inside the region is properly terminated;
   // the auto-generated builders do not guarantee that.
   let skipDefaultBuilders = 1;
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
 
     bool isOptionalSymbol() { return true; }
 
     Optional<StringRef> getName() { return sym_name(); }
 
     static StringRef getVCETripleAttrName() { return "vce_triple"; }
-
-    Block& getBlock() {
-      return this->getOperation()->getRegion(0).front();
-    }
   }];
 }
 
 // -----
 
-def SPV_ModuleEndOp : SPV_Op<"mlir.endmodule", [InModuleScope, Terminator]> {
-  let summary = "The pseudo op that ends a SPIR-V module";
-
-  let description = [{
-    This op terminates the only block inside a `spv.module`'s only region.
-    This op does not have a corresponding SPIR-V instruction and thus will
-    not be serialized into the binary format; it is used solely to satisfy
-    the structual requirement that an block must be ended with a terminator.
-  }];
-
-  let arguments = (ins);
-
-  let results = (outs);
-
-  let assemblyFormat = "attr-dict";
-
-  let verifier = [{ return success(); }];
-
-  let hasOpcode = 0;
-
-  let autogenSerialization = 0;
-}
-
-// -----
-
 def SPV_ReferenceOfOp : SPV_Op<"mlir.referenceof", [NoSideEffect]> {
   let summary = "Reference a specialization constant.";
 
   let description = [{
     Specialization constants in module scope are defined using symbol names.
     This op generates an SSA value that can be used to refer to the symbol
     within function scope for use in ops that expect an SSA value.
     This operation has no corresponding SPIR-V instruction; it's merely used

mlir/lib/Conversion/GPUToSPIRV/CMakeLists.txt

-set(LLVM_TARGET_DEFINITIONS GPUToSPIRV.td)
-mlir_tablegen(GPUToSPIRV.cpp.inc -gen-rewriters)
-add_public_tablegen_target(MLIRGPUToSPIRVIncGen)
-
 add_mlir_conversion_library(MLIRGPUToSPIRV
   GPUToSPIRV.cpp
   GPUToSPIRVPass.cpp
 
   DEPENDS
   MLIRConversionPassIncGen
-  MLIRGPUToSPIRVIncGen
 
   LINK_LIBS PUBLIC
   MLIRGPU
   MLIRIR
   MLIRPass
   MLIRSCFToSPIRV
   MLIRSPIRV
   MLIRSPIRVConversion
   MLIRStandard
   MLIRStandardToSPIRV
   MLIRSupport
   MLIRTransforms
   )

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

 public:
   using OpConversionPattern<gpu::GPUModuleOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(gpu::GPUModuleOp moduleOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
+class GPUModuleEndConversion final
+    : public OpConversionPattern<gpu::ModuleEndOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(gpu::ModuleEndOp endOp, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    rewriter.eraseOp(endOp);
+    return success();
+  }
+};
+
 /// Pattern to convert a gpu.return into a SPIR-V return.
 // TODO: This can go to DRR when GPU return has operands.
 class GPUReturnOpConversion final : public OpConversionPattern<gpu::ReturnOp> {
 public:
   using OpConversionPattern<gpu::ReturnOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(gpu::ReturnOp returnOp, ArrayRef<Value> operands,
LogicalResult GPUModuleConversion::matchAndRewrite(
 
   // Add a keyword to the module name to avoid symbolic conflict.
   std::string spvModuleName = (kSPIRVModule + moduleOp.getName()).str();
   auto spvModule = rewriter.create<spirv::ModuleOp>(
       moduleOp.getLoc(), addressingModel, memoryModel.getValue(),
       StringRef(spvModuleName));
 
   // Move the region from the module op into the SPIR-V module.
-  Region &spvModuleRegion = spvModule.body();
+  Region &spvModuleRegion = spvModule.getRegion();
   rewriter.inlineRegionBefore(moduleOp.body(), spvModuleRegion,
                               spvModuleRegion.begin());
-  // The spv.module build method adds a block with a terminator. Remove that
-  // block. The terminator of the module op in the remaining block will be
-  // legalized later.
+  // The spv.module build method adds a block. Remove that.
   rewriter.eraseBlock(&spvModuleRegion.back());
   rewriter.eraseOp(moduleOp);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU return inside kernel functions to SPIR-V return.
 //===----------------------------------------------------------------------===//
 
 LogicalResult GPUReturnOpConversion::matchAndRewrite(
     gpu::ReturnOp returnOp, ArrayRef<Value> operands,
     ConversionPatternRewriter &rewriter) const {
   if (!operands.empty())
     return failure();
 
   rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU To SPIRV Patterns.
 //===----------------------------------------------------------------------===//
 
-namespace {
-#include "GPUToSPIRV.cpp.inc"
-}
-
 void mlir::populateGPUToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                       RewritePatternSet &patterns) {
-  populateWithGenerated(patterns);
   patterns.add<
-      GPUFuncOpConversion, GPUModuleConversion, GPUReturnOpConversion,
+      GPUFuncOpConversion, GPUModuleConversion, GPUModuleEndConversion,
+      GPUReturnOpConversion,
       LaunchConfigConversion<gpu::BlockIdOp, spirv::BuiltIn::WorkgroupId>,
       LaunchConfigConversion<gpu::GridDimOp, spirv::BuiltIn::NumWorkgroups>,
       LaunchConfigConversion<gpu::ThreadIdOp,
                              spirv::BuiltIn::LocalInvocationId>,
       SingleDimLaunchConfigConversion<gpu::SubgroupIdOp,
                                       spirv::BuiltIn::SubgroupId>,
       SingleDimLaunchConfigConversion<gpu::NumSubgroupsOp,
                                       spirv::BuiltIn::NumSubgroups>,
       SingleDimLaunchConfigConversion<gpu::SubgroupSizeOp,
                                       spirv::BuiltIn::SubgroupSize>,
       WorkGroupSizeConversion>(typeConverter, patterns.getContext());
 }

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.td

-//===-- GPUToSPIRV.td - GPU to SPIR-V Dialect Lowerings ----*- tablegen -*-===//
-//
-// 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 contains patterns to lower GPU dialect ops to to SPIR-V ops.
-//
-//===----------------------------------------------------------------------===//
-
-
-#ifndef MLIR_CONVERSION_GPU_TO_SPIRV
-#define MLIR_CONVERSION_GPU_TO_SPIRV
-
-include "mlir/Dialect/GPU/GPUOps.td"
-include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
-
-def : Pat<(GPU_ModuleEndOp), (SPV_ModuleEndOp)>;
-
-#endif // MLIR_CONVERSION_GPU_TO_SPIRV

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

public:
   using SPIRVToLLVMConversion<spirv::ModuleOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::ModuleOp spvModuleOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto newModuleOp =
         rewriter.create<ModuleOp>(spvModuleOp.getLoc(), spvModuleOp.getName());
-    rewriter.inlineRegionBefore(spvModuleOp.body(), newModuleOp.getBody());
+    rewriter.inlineRegionBefore(spvModuleOp.getRegion(), newModuleOp.getBody());
 
     // Remove the terminator block that was automatically added by builder
     rewriter.eraseBlock(&newModuleOp.getBodyRegion().back());
     rewriter.eraseOp(spvModuleOp);
     return success();
   }
 };
 
-class ModuleEndConversionPattern
-    : public SPIRVToLLVMConversion<spirv::ModuleEndOp> {
-public:
-  using SPIRVToLLVMConversion<spirv::ModuleEndOp>::SPIRVToLLVMConversion;
-
-  LogicalResult
-  matchAndRewrite(spirv::ModuleEndOp moduleEndOp, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const override {
-
-    rewriter.eraseOp(moduleEndOp);
-    return success();
-  }
-};
-
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 void mlir::populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter) {
   typeConverter.addConversion([&](spirv::ArrayType type) {

 
 void mlir::populateSPIRVToLLVMFunctionConversionPatterns(
     LLVMTypeConverter &typeConverter, RewritePatternSet &patterns) {
   patterns.add<FuncConversionPattern>(patterns.getContext(), typeConverter);
 }
 
 void mlir::populateSPIRVToLLVMModuleConversionPatterns(
     LLVMTypeConverter &typeConverter, RewritePatternSet &patterns) {
-  patterns.add<ModuleConversionPattern, ModuleEndConversionPattern>(
-      patterns.getContext(), typeConverter);
+  patterns.add<ModuleConversionPattern>(patterns.getContext(), typeConverter);
 }
 
 //===----------------------------------------------------------------------===//
 // Pre-conversion hooks
 //===----------------------------------------------------------------------===//
 
 /// Hook for descriptor set and binding number encoding.
 static constexpr StringRef kBinding = "binding";

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // spv.module
 //===----------------------------------------------------------------------===//
 
 void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state,
                             Optional<StringRef> name) {
-  ensureTerminator(*state.addRegion(), builder, state.location);
+  OpBuilder::InsertionGuard guard(builder);
+  builder.createBlock(state.addRegion());
   if (name) {
     state.attributes.append(mlir::SymbolTable::getSymbolAttrName(),
                             builder.getStringAttr(*name));
   }
 }
 
 void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state,
                             spirv::AddressingModel addressingModel,
                             spirv::MemoryModel memoryModel,
                             Optional<StringRef> name) {
   state.addAttribute(
       "addressing_model",
       builder.getI32IntegerAttr(static_cast<int32_t>(addressingModel)));
   state.addAttribute("memory_model", builder.getI32IntegerAttr(
                                          static_cast<int32_t>(memoryModel)));
-  ensureTerminator(*state.addRegion(), builder, state.location);
+  OpBuilder::InsertionGuard guard(builder);
+  builder.createBlock(state.addRegion());
   if (name) {
     state.attributes.append(mlir::SymbolTable::getSymbolAttrName(),
                             builder.getStringAttr(*name));
   }
 }
 
 static ParseResult parseModuleOp(OpAsmParser &parser, OperationState &state) {
   Region *body = state.addRegion();
static ParseResult parseModuleOp(OpAsmParser &parser, OperationState &state) {
   }
 
   if (parser.parseOptionalAttrDictWithKeyword(state.attributes))
     return failure();
 
   if (parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{}))
     return failure();
 
-  spirv::ModuleOp::ensureTerminator(*body, parser.getBuilder(), state.location);
+  // Make sure we have at least one block.
+  if (body->empty())
+    body->push_back(new Block());
+
   return success();
 }
 
 static void print(spirv::ModuleOp moduleOp, OpAsmPrinter &printer) {
   printer << spirv::ModuleOp::getOperationName();
 
   if (Optional<StringRef> name = moduleOp.getName()) {
     printer << ' ';
elidedAttrs.assign({addressingModelAttrName, memoryModelAttrName,
                       SymbolTable::getSymbolAttrName()});
 
   if (Optional<spirv::VerCapExtAttr> triple = moduleOp.vce_triple()) {
     printer << " requires " << *triple;
     elidedAttrs.push_back(spirv::ModuleOp::getVCETripleAttrName());
   }
 
   printer.printOptionalAttrDictWithKeyword(moduleOp->getAttrs(), elidedAttrs);
-  printer.printRegion(moduleOp.body(), /*printEntryBlockArgs=*/false,
-                      /*printBlockTerminators=*/false);
+  printer.printRegion(moduleOp.getRegion());
 }
 
 static LogicalResult verify(spirv::ModuleOp moduleOp) {
   auto &op = *moduleOp.getOperation();
   auto *dialect = op.getDialect();
   DenseMap<std::pair<spirv::FuncOp, spirv::ExecutionModel>, spirv::EntryPointOp>
       entryPoints;
   SymbolTable table(moduleOp);
 
-  for (auto &op : moduleOp.getBlock()) {
+  for (auto &op : *moduleOp.getBody()) {
     if (op.getDialect() != dialect)
       return op.emitError("'spv.module' can only contain spv.* ops");
 
     // For EntryPoint op, check that the function and execution model is not
     // duplicated in EntryPointOps. Also verify that the interface specified
     // comes from globalVariables here to make this check cheaper.
     if (auto entryPointOp = dyn_cast<spirv::EntryPointOp>(op)) {
       auto funcOp = table.lookup<spirv::FuncOp>(entryPointOp.fn());

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

combine(llvm::MutableArrayRef<spirv::ModuleOp> modules,
   if (modules.empty())
     return nullptr;
 
   auto addressingModel = modules[0].addressing_model();
   auto memoryModel = modules[0].memory_model();
 
   auto combinedModule = combinedModuleBuilder.create<spirv::ModuleOp>(
       modules[0].getLoc(), addressingModel, memoryModel);
-  combinedModuleBuilder.setInsertionPointToStart(&*combinedModule.getBody());
+  combinedModuleBuilder.setInsertionPointToStart(combinedModule.getBody());
 
   // In some cases, a symbol in the (current state of the) combined module is
   // renamed in order to maintain the conflicting symbol in the input module
   // being merged. For example, if the conflict is between a global variable in
   // the current combined module and a function in the input module, the global
   // variable is renamed. In order to notify listeners of the symbol updates in
   // such cases, we need to keep track of the module from which the renamed
   // symbol in the combined module originated. This map keeps such information.
for (auto module : modules) {
 
     spirv::ModuleOp moduleClone = module.clone();
 
     // In the combined module, rename all symbols that conflict with symbols
     // from the current input module. This renaming applies to all ops except
     // for spv.funcs. This way, if the conflicting op in the input module is
     // non-spv.func, we rename that symbol instead and maintain the spv.func in
     // the combined module name as it is.
-    for (auto &op : combinedModule.getBlock().without_terminator()) {
+    for (auto &op : *combinedModule.getBody()) {
       if (auto symbolOp = dyn_cast<SymbolOpInterface>(op)) {
         StringRef oldSymName = symbolOp.getName();
 
         if (!isa<FuncOp>(op) &&
             failed(updateSymbolAndAllUses(symbolOp, combinedModule, moduleClone,
                                           lastUsedID)))
           return nullptr;
 
for (auto &op : *combinedModule.getBody()) {
           // module in case it gets renamed again later.
           symNameToModuleMap[newSymName] = originalModule;
         }
       }
     }
 
     // In the current input module, rename all symbols that conflict with
     // symbols from the combined module. This includes renaming spv.funcs.
-    for (auto &op : moduleClone.getBlock().without_terminator()) {
+    for (auto &op : *moduleClone.getBody()) {
       if (auto symbolOp = dyn_cast<SymbolOpInterface>(op)) {
         StringRef oldSymName = symbolOp.getName();
 
         if (failed(updateSymbolAndAllUses(symbolOp, moduleClone, combinedModule,
                                           lastUsedID)))
           return nullptr;
 
         StringRef newSymName = symbolOp.getName();
for (auto &op : *moduleClone.getBody()) {
                 << symbolOp.getName();
             return nullptr;
           }
         }
       }
     }
 
     // Clone all the module's ops to the combined module.
-    for (auto &op : moduleClone.getBlock().without_terminator())
+    for (auto &op : *moduleClone.getBody())
       combinedModuleBuilder.insert(op.clone());
   }
 
   // Deduplicate identical global variables, spec constants, and functions.
   DenseMap<llvm::hash_code, SymbolOpInterface> hashToSymbolOp;
   SmallVector<SymbolOpInterface, 0> eraseList;
 
-  for (auto &op : combinedModule.getBlock().without_terminator()) {
+  for (auto &op : *combinedModule.getBody()) {
     llvm::hash_code hashCode(0);
     SymbolOpInterface symbolOp = dyn_cast<SymbolOpInterface>(op);
 
     if (!symbolOp)
       continue;
 
     hashCode = computeHash(symbolOp);
 

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp,
   auto entryPointAttr =
       funcOp->getAttrOfType<spirv::EntryPointABIAttr>(entryPointAttrName);
   if (!entryPointAttr) {
     return failure();
   }
 
   OpBuilder::InsertionGuard moduleInsertionGuard(builder);
   auto spirvModule = funcOp->getParentOfType<spirv::ModuleOp>();
-  builder.setInsertionPoint(spirvModule.body().front().getTerminator());
+  builder.setInsertionPointToEnd(spirvModule.getBody());
 
   // Adds the spv.EntryPointOp after collecting all the interface variables
   // needed.
   SmallVector<Attribute, 1> interfaceVars;
   if (failed(getInterfaceVariables(funcOp, interfaceVars))) {
     return failure();
   }
 

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

 
 //===----------------------------------------------------------------------===//
 // Deserializer Method Definitions
 //===----------------------------------------------------------------------===//
 
 spirv::Deserializer::Deserializer(ArrayRef<uint32_t> binary,
                                   MLIRContext *context)
     : binary(binary), context(context), unknownLoc(UnknownLoc::get(context)),
-      module(createModuleOp()), opBuilder(module->body()) {}
+      module(createModuleOp()), opBuilder(module->getRegion()) {}
 
 LogicalResult spirv::Deserializer::deserialize() {
   LLVM_DEBUG(llvm::dbgs() << "+++ starting deserialization +++\n");
 
   if (failed(processHeader()))
     return failure();
 
   spirv::Opcode opcode = spirv::Opcode::OpNop;

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

LogicalResult Serializer::serialize() {
   // 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()) {
+  for (auto &op : *module.getBody()) {
     if (failed(processOperation(&op))) {
       return failure();
     }
   }
 
   LLVM_DEBUG(llvm::dbgs() << "+++ completed serialization +++\n");
   return success();
 }
return TypeSwitch<Operation *, LogicalResult>(opInst)
         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::SpecConstantOperationOp op) {
         return processSpecConstantOperationOp(op);

mlir/test/Conversion/SPIRVToLLVM/module-ops-to-llvm.mlir

 // CHECK: module @foo
 spv.module @foo Logical GLSL450 {}
 
 // CHECK: module
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> {}
 
 // CHECK: module
 spv.module Logical GLSL450 {
-  // CHECK: }
-  spv.mlir.endmodule
-}
-
-// CHECK: module
-spv.module Logical GLSL450 {
   // CHECK-LABEL: llvm.func @empty()
   spv.func @empty() -> () "None" {
     // CHECK: llvm.return
     spv.Return
   }
 }

mlir/test/Dialect/SPIRV/IR/structure-ops.mlir

 spv.module Logical GLSL450 attributes {foo = "bar"} { }
 
 // Module with VCE triple and additional attributes
 // CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> attributes {foo = "bar"}
 spv.module Logical GLSL450
   requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]>
   attributes {foo = "bar"} { }
 
-// Module with explicit spv.mlir.endmodule
-// CHECK: spv.module
-spv.module Logical GLSL450 {
-  spv.mlir.endmodule
-}
-
 // Module with function
 // CHECK: spv.module
 spv.module Logical GLSL450 {
   spv.func @do_nothing() -> () "None" {
     spv.Return
   }
 }
 

 ^first:
   spv.Return
 ^second:
   spv.Return
 }
 
 // -----
 
-// Module with wrong terminator
-// expected-error@+2 {{expects regions to end with 'spv.mlir.endmodule'}}
-// expected-note@+1 {{in custom textual format, the absence of terminator implies 'spv.mlir.endmodule'}}
-"spv.module"() ({
-  %0 = spv.Constant true
-}) {addressing_model = 0 : i32, memory_model = 1 : i32} : () -> ()
-
-// -----
-
 // Use non SPIR-V op inside module
 spv.module Logical GLSL450 {
   // expected-error @+1 {{'spv.module' can only contain spv.* ops}}
   "dialect.op"() : () -> ()
 }
 
 // -----
 

 spv.module Logical GLSL450 {
   // expected-error @+1 {{'spv.module' cannot contain external functions}}
   spv.func @extern() -> () "None"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.mlir.endmodule
-//===----------------------------------------------------------------------===//
-
-func @module_end_not_in_module() -> () {
-  // expected-error @+1 {{op must appear in a module-like op's block}}
-  spv.mlir.endmodule
-}
-
-// -----
-
-//===----------------------------------------------------------------------===//
 // spv.mlir.referenceof
 //===----------------------------------------------------------------------===//
 
 spv.module Logical GLSL450 {
   spv.SpecConstant @sc1 = false
   spv.SpecConstant @sc2 = 42 : i64
   spv.SpecConstant @sc3 = 1.5 : f32
 

mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

state.addAttribute("vce_triple",
                        spirv::VerCapExtAttr::get(
                            spirv::Version::V_1_0, ArrayRef<spirv::Capability>(),
                            ArrayRef<spirv::Extension>(), &context));
     spirv::ModuleOp::build(builder, state);
     module = cast<spirv::ModuleOp>(Operation::create(state));
   }
 
   Type getFloatStructType() {
-    OpBuilder opBuilder(module->body());
+    OpBuilder opBuilder(module->getRegion());
     llvm::SmallVector<Type, 1> elementTypes{opBuilder.getF32Type()};
     llvm::SmallVector<spirv::StructType::OffsetInfo, 1> offsetInfo{0};
     auto structType = spirv::StructType::get(elementTypes, offsetInfo);
     return structType;
   }
 
   void addGlobalVar(Type type, llvm::StringRef name) {
-    OpBuilder opBuilder(module->body());
+    OpBuilder opBuilder(module->getRegion());
     auto ptrType = spirv::PointerType::get(type, spirv::StorageClass::Uniform);
     opBuilder.create<spirv::GlobalVariableOp>(
         UnknownLoc::get(&context), TypeAttr::get(ptrType),
         opBuilder.getStringAttr(name), nullptr);
   }
 
   bool findInstruction(llvm::function_ref<bool(spirv::Opcode opcode,
                                                ArrayRef<uint32_t> operands)>