[MLIR][SPIRV] Rename `spv._merge` to `spv.mlir.merge`

[ergawy]

Summary

This commit does the renaming mentioned in the title in order to bring
'spv' dialect closer to the MLIR naming conventions.

[antiagainst]

Thanks for this!!

mlir/docs/Dialects/SPIR-V.md

*   Ops that directly mirror instructions in the specification have `CamelCase`
     prefix). For example, `spv.FMul` is a direct mirror of `OpFMul` in the
     specification. Such an op will be serialized into and deserialized from one
     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 `_snake_case` names are those that have no corresponding
+*   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._module_end` and
-    `spv._merge`. They map to no instructions during (de)serialization.
+    satisfy MLIR structural requirements. For example, `spv.mlir.module_end` and
+    `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,

 
 In the SPIR-V dialect, we use regions to mark the boundary of a structured
 control flow construct. With this approach, it's easier to discover all blocks
 belonging to a structured control flow construct. It is also more idiomatic to
 MLIR system.
 
 We introduce a `spv.selection` and `spv.loop` op for structured selections and
 loops, respectively. The merge targets are the next ops following them. Inside
-their regions, a special terminator, `spv._merge` is introduced for branching to
+their regions, a special terminator, `spv.mlir.merge` is introduced for branching to
 the merge target.
 
 ### Selection
 
 `spv.selection` defines a selection construct. It contains one region. The
 region should contain at least two blocks: one selection header block and one
 merge block.
 
 *   The selection header block should be the first block. It should contain the
     `spv.BranchConditional` or `spv.Switch` op.
 *   The merge block should be the last block. The merge block should only
-    contain a `spv._merge` op. Any block can branch to the merge block for early
+    contain a `spv.mlir.merge` op. Any block can branch to the merge block for early
     exit.
 
 ```
                +--------------+
                | header block |                 (may have multiple outgoing branches)
                +--------------+
                     / | \
                      ...
^then:
     spv.Store "Function" %x, %one : i32
     spv.Branch ^merge
 
   ^else:
     spv.Store "Function" %x, %two : i32
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
 
   // ...
 }
 
 ```
 
 ### Loop
 
 `spv.loop` defines a loop construct. It contains one region. The region should
 contain at least four blocks: one entry block, one loop header block, one loop
 continue block, one merge block.
 
 *   The entry block should be the first block and it should jump to the loop
     header block, which is the second block.
 *   The merge block should be the last block. The merge block should only
-    contain a `spv._merge` op. Any block except the entry block can branch to
+    contain a `spv.mlir.merge` op. Any block except the entry block can branch to
     the merge block for early exit.
 *   The continue block should be the second to last block and it should have a
     branch to the loop header block.
 *   The loop continue block should be the only block, except the entry block,
     branching to the loop header block.
 
 ```
     +-------------+
func @loop(%count : i32) -> () {
 
   ^continue:
     %val1 = spv.Load "Function" %var : i32
     %add = spv.IAdd %val1, %one : i32
     spv.Store "Function" %var, %add : i32
     spv.Branch ^header
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 ```
 
 ### Block argument for Phi
 
 There are no direct Phi operations in the SPIR-V dialect; SPIR-V `OpPhi`
^false:
     %one = spv.constant 1 : i32
     spv.Branch ^phi(%one: i32)
 
   ^phi(%arg: i32):
     spv.Store "Function" %var, %arg : i32
     spv.Return
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 ```
 
 ## Version, extensions, capabilities
 
 SPIR-V supports versions, extensions, and capabilities as ways to indicate the

mlir/docs/SPIRVToLLVMDialectConversion.md

^true:                                                ^true:
   // True block code                                    // True block code
   spv.Branch ^merge                             =>      llvm.br ^merge
 
 ^false:                                               ^false:
   // False block code                                   // False block code
   spv.Branch ^merge                                     llvm.br ^merge
 
 ^merge:                                               ^merge:
-  spv._merge                                            llvm.br ^continue
+  spv.mlir.merge                                            llvm.br ^continue
 }
 // Remaining code                                     ^continue:
                                                         // Remaining code
 ```
 
 ```mlir
 // Conversion of loop
 %cond = spv.constant true                               %cond = llvm.mlir.constant(true) : !llvm.i1
 spv.loop {
   spv.Branch ^header                                    llvm.br ^header
 
 ^header:                                              ^header:
   // Header code                                        // Header code
   spv.BranchConditional %cond, ^body, ^merge    =>      llvm.cond_br %cond, ^body, ^merge
 
 ^body:                                                ^body:
   // Body code                                          // Body code
   spv.Branch ^continue                                  llvm.br ^continue
 
 ^continue:                                            ^continue:
   // Continue code                                      // Continue code
   spv.Branch ^header                                    llvm.br ^header
 
 ^merge:                                               ^merge:
-  spv._merge                                            llvm.br ^remaining
+  spv.mlir.merge                                            llvm.br ^remaining
 }
 // Remaining code                                     ^remaining:
                                                         // Remaining code
 ```
 
 ## Decorations conversion
 
 **Note: these conversions have not been implemented yet**

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

let description = [{
     has a back-edge pointing to the entry block inside the `spv.loop`'s region.
     This way it's easier to discover all blocks belonging to a construct and
     it plays nicer with the MLIR system.
 
     The `spv.loop` region should contain at least four blocks: one entry block,
     one loop header block, one loop continue block, one loop merge block.
     The entry block should be the first block and it should jump to the loop
     header block, which is the second block. The loop merge block should be the
-    last block. The merge block should only contain a `spv._merge` op.
+    last block. The merge block should only contain a `spv.mlir.merge` op.
     The continue block should be the second to last block and it should have a
     branch to the loop header block. The loop continue block should be the only
     block, except the entry block, branching to the header block.
   }];
 
   let arguments = (ins
     SPV_LoopControlAttr:$loop_control
   );
let extraClassDeclaration = [{
 
     // Returns the loop continue block.
     Block *getContinueBlock();
 
     // Returns the loop merge block.
     Block *getMergeBlock();
 
     // Adds an empty entry block and loop merge block containing one
-    // spv._merge op.
+    // spv.mlir.merge op.
     void addEntryAndMergeBlock();
   }];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
-def SPV_MergeOp : SPV_Op<"_merge", [NoSideEffect, Terminator]> {
+def SPV_MergeOp : SPV_Op<"mlir.merge", [NoSideEffect, Terminator]> {
   let summary = "A special terminator for merging a structured selection/loop.";
 
   let description = [{
     We use `spv.selection`/`spv.loop` for modelling structured selection/loop.
     This op is a terminator used inside their regions to mean jumping to the
     merge point, which is the next op following the `spv.selection` or
     `spv.loop` op. This op does not have a corresponding instruction in the
     SPIR-V binary format; it's solely for structural purpose.
let description = [{
     merge instruction for indicating the merge target, we use regions to delimit
     the boundary of the selection: the merge target is the next op following the
     `spv.selection` op. This way it's easier to discover all blocks belonging to
     the selection and it plays nicer with the MLIR system.
 
     The `spv.selection` region should contain at least two blocks: one selection
     header block, and one selection merge. The selection header block should be
     the first block. The selection merge block should be the last block.
-    The merge block should only contain a `spv._merge` op.
+    The merge block should only contain a `spv.mlir.merge` op.
   }];
 
   let arguments = (ins
     SPV_SelectionControlAttr:$selection_control
   );
 
   let results = (outs);
 
   let regions = (region AnyRegion:$body);
 
   let extraClassDeclaration = [{
     /// Returns the selection header block.
     Block *getHeaderBlock();
 
     /// Returns the selection merge block.
     Block *getMergeBlock();
 
-    /// Adds a selection merge block containing one spv._merge op.
+    /// Adds a selection merge block containing one spv.mlir.merge op.
     void addMergeBlock();
 
     /// Creates a spv.selection op for `if (<condition>) then { <thenBody> }`
     /// with `builder`. `builder`'s insertion point will remain at after the
     /// newly inserted spv.selection op afterwards.
     static SelectionOp createIfThen(
         Location loc, Value condition,
         function_ref<void(OpBuilder &builder)> thenBody,

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 static Type getElementType(Type type, Attribute indices, OpAsmParser &parser,
                            llvm::SMLoc loc) {
   auto errorFn = [&](StringRef err) -> InFlightDiagnostic {
     return parser.emitError(loc, err);
   };
   return getElementType(type, indices, errorFn);
 }
 
-/// Returns true if the given `block` only contains one `spv._merge` op.
+/// Returns true if the given `block` only contains one `spv.mlir.merge` op.
 static inline bool isMergeBlock(Block &block) {
   return !block.empty() && std::next(block.begin()) == block.end() &&
          isa<spirv::MergeOp>(block.front());
 }
 
 //===----------------------------------------------------------------------===//
 // Common parsers and printers
 //===----------------------------------------------------------------------===//
static LogicalResult verify(spirv::LoopOp loopOp) {
   // optimizations.
   if (region.empty())
     return success();
 
   // The last block is the merge block.
   Block &merge = region.back();
   if (!isMergeBlock(merge))
     return loopOp.emitOpError(
-        "last block must be the merge block with only one 'spv._merge' op");
+        "last block must be the merge block with only one 'spv.mlir.merge' op");
 
   if (std::next(region.begin()) == region.end())
     return loopOp.emitOpError(
         "must have an entry block branching to the loop header block");
   // The first block is the entry block.
   Block &entry = region.front();
 
   if (std::next(region.begin(), 2) == region.end())

 
 void spirv::LoopOp::addEntryAndMergeBlock() {
   assert(body().empty() && "entry and merge block already exist");
   body().push_back(new Block());
   auto *mergeBlock = new Block();
   body().push_back(mergeBlock);
   OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock);
 
-  // Add a spv._merge op into the merge block.
+  // Add a spv.mlir.merge op into the merge block.
   builder.create<spirv::MergeOp>(getLoc());
 }
 
 //===----------------------------------------------------------------------===//
-// spv._merge
+// spv.mlir.merge
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(spirv::MergeOp mergeOp) {
   auto *parentOp = mergeOp.getParentOp();
   if (!parentOp || !isa<spirv::SelectionOp, spirv::LoopOp>(parentOp))
     return mergeOp.emitOpError(
         "expected parent op to be 'spv.selection' or 'spv.loop'");
 
static LogicalResult verify(spirv::SelectionOp selectionOp) {
   // Allow empty region as a degenerated case, which can come from
   // optimizations.
   if (region.empty())
     return success();
 
   // The last block is the merge block.
   if (!isMergeBlock(region.back()))
     return selectionOp.emitOpError(
-        "last block must be the merge block with only one 'spv._merge' op");
+        "last block must be the merge block with only one 'spv.mlir.merge' op");
 
   if (std::next(region.begin()) == region.end())
     return selectionOp.emitOpError("must have a selection header block");
 
   return success();
 }
 
 Block *spirv::SelectionOp::getHeaderBlock() {

 }
 
 void spirv::SelectionOp::addMergeBlock() {
   assert(body().empty() && "entry and merge block already exist");
   auto *mergeBlock = new Block();
   body().push_back(mergeBlock);
   OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock);
 
-  // Add a spv._merge op into the merge block.
+  // Add a spv.mlir.merge op into the merge block.
   builder.create<spirv::MergeOp>(getLoc());
 }
 
 spirv::SelectionOp spirv::SelectionOp::createIfThen(
     Location loc, Value condition,
     function_ref<void(OpBuilder &builder)> thenBody, OpBuilder &builder) {
   auto selectionControl = builder.getI32IntegerAttr(
       static_cast<uint32_t>(spirv::SelectionControl::None));

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

LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   // 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._merge op, itself. But we need to have an OpLabel
+  // 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
if (failed(visitInPrettyBlockOrder(
           /*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._merge op, itself. But we need to have an OpLabel instruction to
+  // 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());

mlir/test/Conversion/GPUToSPIRV/if.mlir

attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       %value = constant 0.0 : f32
       %i = constant 0 : index
 
       // CHECK:       spv.selection {
       // CHECK-NEXT:    spv.BranchConditional {{%.*}}, [[TRUE:\^.*]], [[MERGE:\^.*]]
       // CHECK-NEXT:  [[TRUE]]:
       // CHECK:         spv.Branch [[MERGE]]
       // CHECK-NEXT:  [[MERGE]]:
-      // CHECK-NEXT:    spv._merge
+      // CHECK-NEXT:    spv.mlir.merge
       // CHECK-NEXT:  }
       // CHECK-NEXT:  spv.Return
 
       scf.if %arg3 {
         store %value, %arg2[%i] : memref<10xf32>
       }
       gpu.return
     }
attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       // CHECK-NEXT:  [[TRUE_TOP]]:
       // CHECK-NEXT:    spv.selection {
       // CHECK-NEXT:      spv.BranchConditional {{%.*}}, [[TRUE_NESTED_TRUE_PATH:\^.*]], [[FALSE_NESTED_TRUE_PATH:\^.*]]
       // CHECK-NEXT:    [[TRUE_NESTED_TRUE_PATH]]:
       // CHECK:           spv.Branch [[MERGE_NESTED_TRUE_PATH:\^.*]]
       // CHECK-NEXT:    [[FALSE_NESTED_TRUE_PATH]]:
       // CHECK:           spv.Branch [[MERGE_NESTED_TRUE_PATH]]
       // CHECK-NEXT:    [[MERGE_NESTED_TRUE_PATH]]:
-      // CHECK-NEXT:      spv._merge
+      // CHECK-NEXT:      spv.mlir.merge
       // CHECK-NEXT:    }
       // CHECK-NEXT:    spv.Branch [[MERGE_TOP:\^.*]]
       // CHECK-NEXT:  [[FALSE_TOP]]:
       // CHECK-NEXT:    spv.selection {
       // CHECK-NEXT:      spv.BranchConditional {{%.*}}, [[TRUE_NESTED_FALSE_PATH:\^.*]], [[FALSE_NESTED_FALSE_PATH:\^.*]]
       // CHECK-NEXT:    [[TRUE_NESTED_FALSE_PATH]]:
       // CHECK:           spv.Branch [[MERGE_NESTED_FALSE_PATH:\^.*]]
       // CHECK-NEXT:    [[FALSE_NESTED_FALSE_PATH]]:
       // CHECK:           spv.Branch [[MERGE_NESTED_FALSE_PATH]]
       // CHECK:         [[MERGE_NESTED_FALSE_PATH]]:
-      // CHECK-NEXT:      spv._merge
+      // CHECK-NEXT:      spv.mlir.merge
       // CHECK-NEXT:    }
       // CHECK-NEXT:    spv.Branch [[MERGE_TOP]]
       // CHECK-NEXT:  [[MERGE_TOP]]:
-      // CHECK-NEXT:    spv._merge
+      // CHECK-NEXT:    spv.mlir.merge
       // CHECK-NEXT:  }
       // CHECK-NEXT:  spv.Return
 
       scf.if %arg5 {
         scf.if %arg6 {
           %value = load %arg3[%i] : memref<10xf32>
           store %value, %arg4[%i] : memref<10xf32>
         } else {
attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       // CHECK:         spv.Branch ^[[MERGE:.*]]
       // CHECK-NEXT:  [[FALSE]]:
       // CHECK:         %[[RET2FALSE:.*]] = spv.constant 2.000000e+00 : f32
       // CHECK:         %[[RET1FALSE:.*]] = spv.constant 3.000000e+00 : f32
       // CHECK-DAG:     spv.Store "Function" %[[VAR1]], %[[RET1FALSE]] : f32
       // CHECK-DAG:     spv.Store "Function" %[[VAR2]], %[[RET2FALSE]] : f32
       // CHECK:         spv.Branch ^[[MERGE]]
       // CHECK-NEXT:  ^[[MERGE]]:
-      // CHECK:         spv._merge
+      // CHECK:         spv.mlir.merge
       // CHECK-NEXT:  }
       // CHECK-DAG:   %[[OUT1:.*]] = spv.Load "Function" %[[VAR1]] : f32
       // CHECK-DAG:   %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32
       // CHECK:       spv.Store "StorageBuffer" {{%.*}}, %[[OUT1]] : f32
       // CHECK:       spv.Store "StorageBuffer" {{%.*}}, %[[OUT2]] : f32
       // CHECK:       spv.Return
       %0:2 = scf.if %arg3 -> (f32, f32) {
         %c0 = constant 0.0 : f32
gpu.module @kernels {
     // CHECK-NEXT:    spv.BranchConditional {{%.*}}, [[TRUE:\^.*]], [[FALSE:\^.*]]
     // CHECK-NEXT:  [[TRUE]]:
     // CHECK:         spv.Store "Function" %[[VAR]], {{%.*}} : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
     // CHECK:         spv.Branch ^[[MERGE:.*]]
     // CHECK-NEXT:  [[FALSE]]:
     // CHECK:         spv.Store "Function" %[[VAR]], {{%.*}} : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
     // CHECK:         spv.Branch ^[[MERGE]]
     // CHECK-NEXT:  ^[[MERGE]]:
-    // CHECK:         spv._merge
+    // CHECK:         spv.mlir.merge
     // CHECK-NEXT:  }
     // CHECK:       %[[OUT:.*]] = spv.Load "Function" %[[VAR]] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
     // CHECK:       %[[ADD:.*]] = spv.AccessChain %[[OUT]][{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
     // CHECK:       spv.Store "StorageBuffer" %[[ADD]], {{%.*}} : f32
     // CHECK:       spv.Return
     gpu.func @simple_if_yield_type_change(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>, %arg4 : i1) kernel
     attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       %i = constant 0 : index

mlir/test/Conversion/GPUToSPIRV/loop.mlir

attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       // CHECK:        %[[OFFSET2:.*]] = spv.constant 0 : i32
       // CHECK:        %[[STRIDE2:.*]] = spv.constant 1 : i32
       // CHECK:        %[[UPDATE2:.*]] = spv.IMul %[[STRIDE2]], %[[INDVAR]] : i32
       // CHECK:        %[[INDEX2:.*]] = spv.IAdd %[[OFFSET2]], %[[UPDATE2]] : i32
       // CHECK:        spv.AccessChain {{%.*}}[%[[ZERO2]], %[[INDEX2]]]
       // CHECK:        %[[INCREMENT:.*]] = spv.IAdd %[[INDVAR]], %[[STEP]] : i32
       // CHECK:        spv.Branch ^[[HEADER]](%[[INCREMENT]] : i32)
       // CHECK:      ^[[MERGE]]
-      // CHECK:        spv._merge
+      // CHECK:        spv.mlir.merge
       // CHECK:      }
       scf.for %arg4 = %lb to %ub step %step {
         %1 = load %arg2[%arg4] : memref<10xf32>
         store %1, %arg3[%arg4] : memref<10xf32>
       }
       gpu.return
     }
 
attributes {spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}} {
       // CHECK:   spv.BranchConditional %[[CMP]], ^[[BODY:.*]], ^[[MERGE:.*]]
       // CHECK: ^[[BODY]]:
       // CHECK:   %[[UPDATED:.*]] = spv.FAdd %[[CARRIED1]], %[[CARRIED1]] : f32
       // CHECK-DAG:   %[[INCREMENT:.*]] = spv.IAdd %[[INDVAR]], %[[STEP]] : i32
       // CHECK-DAG:   spv.Store "Function" %[[VAR1]], %[[UPDATED]] : f32
       // CHECK-DAG:   spv.Store "Function" %[[VAR2]], %[[UPDATED]] : f32
       // CHECK: spv.Branch ^[[HEADER]](%[[INCREMENT]], %[[UPDATED]], %[[UPDATED]] : i32, f32, f32)
       // CHECK: ^[[MERGE]]:
-      // CHECK:   spv._merge
+      // CHECK:   spv.mlir.merge
       // CHECK: }
       %result:2 = scf.for %i0 = %lb to %ub step %step iter_args(%si = %s0, %sj = %s1) -> (f32, f32) {
         %sn = addf %si, %si : f32
         scf.yield %sn, %sn : f32, f32
       }
       // CHECK-DAG: %[[OUT1:.*]] = spv.Load "Function" %[[VAR1]] : f32
       // CHECK-DAG: %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32
       // CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT1]] : f32
       // CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT2]] : f32
       store %result#0, %arg3[%lb] : memref<10xf32>
       store %result#1, %arg3[%ub] : memref<10xf32>
       gpu.return
     }
   }
 }

mlir/test/Conversion/LinalgToSPIRV/linalg-to-spirv.mlir

 // CHECK:        %[[ELECT:.+]] = spv.GroupNonUniformElect "Subgroup" : i1
 
 // CHECK:        spv.selection {
 // CHECK:          spv.BranchConditional %[[ELECT]], ^bb1, ^bb2
 // CHECK:        ^bb1:
 // CHECK:          spv.AtomicIAdd "Device" "AcquireRelease" %[[OUTPTR]], %[[ADD]]
 // CHECK:          spv.Branch ^bb2
 // CHECK:        ^bb2:
-// CHECK:          spv._merge
+// CHECK:          spv.mlir.merge
 // CHECK:        }
 // CHECK:        spv.Return
 
 func @single_workgroup_reduction(%input: memref<16xi32>, %output: memref<1xi32>) attributes {
   spv.entry_point_abi = {local_size = dense<[16, 1, 1]>: vector<3xi32>}
 } {
   linalg.generic #single_workgroup_reduction_trait
       ins(%input : memref<16xi32>)

mlir/test/Conversion/SPIRVToLLVM/control-flow-ops-to-llvm.mlir

^header:
       spv.BranchConditional %cond, ^body, ^merge
     ^body:
       // Do nothing
       spv.Branch ^continue
     ^continue:
       // Do nothing
       spv.Branch ^header
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 {
   }
 
   spv.func @selection_with_merge_block_only() -> () "None" {
     %cond = spv.constant true
     // CHECK: llvm.return
     spv.selection {
       spv.BranchConditional %cond, ^merge, ^merge
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   spv.func @selection_with_true_block_only() -> () "None" {
     // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1
     %cond = spv.constant true
     // CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2
     spv.selection {
       spv.BranchConditional %cond, ^true, ^merge
     // CHECK: ^bb1:
     ^true:
     // CHECK: llvm.br ^bb2
       spv.Branch ^merge
     // CHECK: ^bb2:
     ^merge:
       // CHECK: llvm.br ^bb3
-      spv._merge
+      spv.mlir.merge
     }
     // CHECK: ^bb3:
     // CHECK-NEXT: llvm.return
     spv.Return
   }
 
   spv.func @selection_with_both_true_and_false_block() -> () "None" {
     // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1
     %cond = spv.constant true
     // CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2
     spv.selection {
       spv.BranchConditional %cond, ^true, ^false
     // CHECK: ^bb1:
     ^true:
     // CHECK: llvm.br ^bb3
       spv.Branch ^merge
     // CHECK: ^bb2:
     ^false:
     // CHECK: llvm.br ^bb3
       spv.Branch ^merge
     // CHECK: ^bb3:
     ^merge:
       // CHECK: llvm.br ^bb4
-      spv._merge
+      spv.mlir.merge
     }
     // CHECK: ^bb4:
     // CHECK-NEXT: llvm.return
     spv.Return
   }
 
   spv.func @selection_with_early_return(%arg0: i1) -> i32 "None" {
     // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
     %0 = spv.constant 0 : i32
     // CHECK: llvm.cond_br %{{.*}}, ^bb1(%[[ZERO]] : !llvm.i32), ^bb2
     spv.selection {
       spv.BranchConditional %arg0, ^true(%0 : i32), ^merge
     // CHECK: ^bb1(%[[ARG:.*]]: !llvm.i32):
     ^true(%arg1: i32):
       // CHECK: llvm.return %[[ARG]] : !llvm.i32
       spv.ReturnValue %arg1 : i32
     // CHECK: ^bb2:
     ^merge:
       // CHECK: llvm.br ^bb3
-      spv._merge
+      spv.mlir.merge
     }
     // CHECK: ^bb3:
     %one = spv.constant 1 : i32
     spv.ReturnValue %one : i32
   }
 }

mlir/test/Dialect/SPIRV/Serialization/debug.mlir

^body:
       ^continue:
         %jval1 = spv.Load "Function" %jvar : i32
         %add = spv.IAdd %jval1, %one : i32
         spv.Store "Function" %jvar, %add : i32
         // CHECK: loc({{".*debug.mlir"}}:101:9)
         spv.Branch ^header
       ^merge:
         // CHECK: loc({{".*debug.mlir"}}:85:7)
-        spv._merge
+        spv.mlir.merge
         // CHECK: loc({{".*debug.mlir"}}:85:7)
       }
       // CHECK: loc({{".*debug.mlir"}}:108:7)
       spv.Branch ^continue
     ^continue:
       %ival1 = spv.Load "Function" %ivar : i32
       %add = spv.IAdd %ival1, %one : i32
       spv.Store "Function" %ivar, %add : i32
       // CHECK: loc({{".*debug.mlir"}}:114:7)
       spv.Branch ^header
     ^merge:
       // CHECK: loc({{".*debug.mlir"}}:75:5)
-      spv._merge
+      spv.mlir.merge
     // CHECK: loc({{".*debug.mlir"}}:75:5)
     }
     spv.Return
   }
 
   spv.func @selection(%cond: i1) -> () "None" {
     %zero = spv.constant 0: i32
     %one = spv.constant 1: i32
     %two = spv.constant 2: i32
     %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
     spv.selection {
       // CHECK: loc({{".*debug.mlir"}}:128:5)
       spv.BranchConditional %cond [5, 10], ^then, ^else
     ^then:
       spv.Store "Function" %var, %one : i32
       // CHECK: loc({{".*debug.mlir"}}:134:7)
       spv.Branch ^merge
     ^else:
       spv.Store "Function" %var, %two : i32
       // CHECK: loc({{".*debug.mlir"}}:138:7)
       spv.Branch ^merge
     ^merge:
       // CHECK: loc({{".*debug.mlir"}}:128:5)
-      spv._merge
+      spv.mlir.merge
     // CHECK: loc({{".*debug.mlir"}}:128:5)
     }
     spv.Return
   }
 }

mlir/test/Dialect/SPIRV/Serialization/function-call.mlir

^header:
       spv.BranchConditional %cmp, ^body, ^merge
     ^body:
       spv.Branch ^continue
     ^continue:
       // CHECK: spv.FunctionCall @f_inc({{%.*}}) : (!spv.ptr<i32, Function>) -> ()
       spv.FunctionCall @f_inc(%var) : (!spv.ptr<i32, Function>) -> ()
       spv.Branch ^header
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
   spv.func @f_inc(%arg0 : !spv.ptr<i32, Function>) -> () "None" {
       %one = spv.constant 1 : i32
       %0 = spv.Load "Function" %arg0 : i32
       %1 = spv.IAdd %0, %one : i32
       spv.Store "Function" %arg0, %1 : i32
       spv.Return
   }
 }

mlir/test/Dialect/SPIRV/Serialization/loop.mlir

 // CHECK-NEXT:     spv.IAdd
       %add = spv.IAdd %val1, %one : i32
 // CHECK-NEXT:     spv.Store
       spv.Store "Function" %var, %add : i32
 // CHECK-NEXT:     spv.Branch ^bb1
       spv.Branch ^header
 
 // CHECK-NEXT:   ^bb4:
-// CHECK-NEXT:     spv._merge
+// CHECK-NEXT:     spv.mlir.merge
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   spv.func @main() -> () "None" {
     spv.Return
   }
   spv.EntryPoint "GLCompute" @main
^body:
       %13 = spv.AccessChain %5[%9] : !spv.ptr<!spv.array<10 x f32, stride=4>, StorageBuffer>, i32
       spv.Store "StorageBuffer" %13, %12 : f32
 // CHECK:          %[[ADD:.*]] = spv.IAdd
       %14 = spv.IAdd %9, %8 : i32
 // CHECK-NEXT:     spv.Branch ^bb1(%[[ADD]] : i32)
       spv.Branch ^header(%14 : i32)
 // CHECK-NEXT:   ^bb3:
     ^merge:
-// CHECK-NEXT:     spv._merge
-      spv._merge
+// CHECK-NEXT:     spv.mlir.merge
+      spv.mlir.merge
     }
     spv.Return
   }
   spv.EntryPoint "GLCompute" @loop_kernel
   spv.ExecutionMode @loop_kernel "LocalSize", 1, 1, 1
 }
 
 // -----
// CHECK-NEXT:       spv.IAdd
         %add = spv.IAdd %jval1, %one : i32
 // CHECK-NEXT:       spv.Store
         spv.Store "Function" %jvar, %add : i32
 // CHECK-NEXT:       spv.Branch ^bb1
         spv.Branch ^header
 
 // CHECK-NEXT:     ^bb4:
       ^merge:
-// CHECK-NEXT:       spv._merge
-        spv._merge
+// CHECK-NEXT:       spv.mlir.merge
+        spv.mlir.merge
       } // end inner loop
 
 // CHECK:          spv.Branch ^bb4
       spv.Branch ^continue
 
 // CHECK-NEXT:   ^bb4:
     ^continue:
 // CHECK-NEXT:     spv.Load
       %ival1 = spv.Load "Function" %ivar : i32
 // CHECK-NEXT:     spv.constant 1
 // CHECK-NEXT:     spv.IAdd
       %add = spv.IAdd %ival1, %one : i32
 // CHECK-NEXT:     spv.Store
       spv.Store "Function" %ivar, %add : i32
 // CHECK-NEXT:     spv.Branch ^bb1
       spv.Branch ^header
 
 // CHECK-NEXT:   ^bb5:
-// CHECK-NEXT:     spv._merge
+// CHECK-NEXT:     spv.mlir.merge
     ^merge:
-      spv._merge
+      spv.mlir.merge
     } // end outer loop
     spv.Return
   }
 
   spv.func @main() -> () "None" {
     spv.Return
   }
   spv.EntryPoint "GLCompute" @main
 }
 

mlir/test/Dialect/SPIRV/Serialization/phi.mlir

// CHECK-NEXT: ^bb3(%[[ARG:.*]]: i32):
     ^phi(%arg: i32):
 // CHECK-NEXT:   spv.Store "Function" %{{.*}}, %[[ARG]] : i32
       spv.Store "Function" %var, %arg : i32
 // CHECK-NEXT:   spv.Return
       spv.Return
 
 // CHECK-NEXT: ^bb4:
     ^merge:
-// CHECK-NEXT:   spv._merge
-      spv._merge
+// CHECK-NEXT:   spv.mlir.merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   spv.func @main() -> () "None" {
     spv.Return
   }
   spv.EntryPoint "GLCompute" @main

 // CHECK:     ^[[LP2_BDY]]:
       ^bb2:
 // CHECK:       %[[ADD1:.*]] = spv.IAdd
         %48 = spv.IAdd %37, %35 : i32
 // CHECK:       spv.Branch ^[[LP2_HDR]](%[[ADD1]] : i32)
         spv.Branch ^bb1(%48 : i32)
 // CHECK:     ^[[LP2_MG]]:
       ^bb3:
-// CHECK:       spv._merge
-        spv._merge
+// CHECK:       spv.mlir.merge
+        spv.mlir.merge
       }
 // CHECK:     %[[ADD2:.*]] = spv.IAdd %[[LP1_HDR_ARG]]
       %36 = spv.IAdd %32, %31 : i32
 // CHECK:     spv.Branch ^[[LP1_HDR]](%[[ADD2]] : i32)
       spv.Branch ^bb1(%36 : i32)
 // CHECK:   ^[[LP1_MG]]:
     ^bb3:
-// CHECK:     spv._merge
-      spv._merge
+// CHECK:     spv.mlir.merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   spv.EntryPoint "GLCompute" @fmul_kernel, @__builtin_var_WorkgroupId__, @__builtin_var_NumWorkgroups__
   spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1
 }
 
spv.loop { // loop 1
       spv.Branch ^bb1(%val1 : i32)
     ^bb1(%loop1_bb_arg: i32):
       %loop1_lt = spv.SLessThan %loop1_bb_arg, %cst4 : i32
       spv.BranchConditional %loop1_lt, ^bb2, ^bb3
     ^bb2:
       %loop1_add = spv.IAdd %loop1_bb_arg, %cst4 : i32
       spv.Branch ^bb1(%loop1_add : i32)
     ^bb3:
-      spv._merge
+      spv.mlir.merge
     }
 
 // CHECK:        spv.constant 44
 // CHECK-NEXT:   spv.Branch ^[[BB2:.+]](%{{.+}} : i32)
 // CHECK-NEXT: ^[[BB2]](%{{.+}}: i32):
 // CHECK-NEXT:   spv.loop
     spv.loop { // loop 2
       spv.Branch ^bb1(%val2 : i32)
     ^bb1(%loop2_bb_arg: i32):
       %loop2_lt = spv.SLessThan %loop2_bb_arg, %cst4 : i32
       spv.BranchConditional %loop2_lt, ^bb2, ^bb3
     ^bb2:
       %loop2_add = spv.IAdd %loop2_bb_arg, %cst4 : i32
       spv.Branch ^bb1(%loop2_add : i32)
     ^bb3:
-      spv._merge
+      spv.mlir.merge
     }
 
     spv.Return
   }
 
   spv.EntryPoint "GLCompute" @fmul_kernel
   spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1
 }

mlir/test/Dialect/SPIRV/Serialization/selection.mlir

 // CHECK-NEXT:     spv.constant 2
 // CHECK-NEXT:     spv.Store
       spv.Store "Function" %var, %two : i32
 // CHECK-NEXT:     spv.Branch ^bb3
       spv.Branch ^merge
 
 // CHECK-NEXT:   ^bb3:
     ^merge:
-// CHECK-NEXT:     spv._merge
-      spv._merge
+// CHECK-NEXT:     spv.mlir.merge
+      spv.mlir.merge
     }
 
     spv.Return
   }
 
   spv.func @main() -> () "None" {
     spv.Return
   }

 
 // CHECK:        ^bb1:
     ^then:
       %zero = spv.constant 0 : i32
       spv.ReturnValue  %zero : i32
 
 // CHECK:        ^bb2:
     ^merge:
-// CHECK-NEXT:     spv._merge
-      spv._merge
+// CHECK-NEXT:     spv.mlir.merge
+      spv.mlir.merge
     }
 
     %one = spv.constant 1 : i32
     spv.ReturnValue  %one : i32
   }
 
   spv.func @main() -> () "None" {
     spv.Return
   }
   spv.EntryPoint "GLCompute" @main
   spv.ExecutionMode @main "LocalSize", 1, 1, 1
 }
 

mlir/test/Dialect/SPIRV/Transforms/inlining.mlir

 
 spv.module Logical GLSL450 {
   spv.func @callee(%cond : i1) -> () "None" {
     spv.selection {
       spv.BranchConditional %cond, ^then, ^merge
     ^then:
       spv.Return
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   // CHECK-LABEL: @calling_selection_ret_func
   spv.func @calling_selection_ret_func() "None" {
     %0 = spv.constant true
     // CHECK: spv.FunctionCall
     spv.FunctionCall @callee(%0) : (i1) -> ()
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   spv.func @callee(%cond : i1) -> () "None" {
     spv.selection {
       spv.BranchConditional %cond, ^then, ^merge
     ^then:
       spv.Branch ^merge
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   // CHECK-LABEL: @calling_selection_no_ret_func
   spv.func @calling_selection_no_ret_func() "None" {
     // CHECK-NEXT: %[[TRUE:.*]] = spv.constant true
     %0 = spv.constant true
     // CHECK-NEXT: spv.selection
     // CHECK-NEXT:   spv.BranchConditional %[[TRUE]], ^bb1, ^bb2
     // CHECK-NEXT: ^bb1:
     // CHECK-NEXT:   spv.Branch ^bb2
     // CHECK-NEXT: ^bb2:
-    // CHECK-NEXT:   spv._merge
+    // CHECK-NEXT:   spv.mlir.merge
     spv.FunctionCall @callee(%0) : (i1) -> ()
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   spv.func @callee(%cond : i1) -> () "None" {
     spv.loop {
       spv.Branch ^header
     ^header:
       spv.BranchConditional %cond, ^body, ^merge
     ^body:
       spv.Return
     ^continue:
       spv.Branch ^header
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   // CHECK-LABEL: @calling_loop_ret_func
   spv.func @calling_loop_ret_func() "None" {
     %0 = spv.constant true
     // CHECK: spv.FunctionCall
spv.loop {
       spv.Branch ^header
     ^header:
       spv.BranchConditional %cond, ^body, ^merge
     ^body:
       spv.Branch ^continue
     ^continue:
       spv.Branch ^header
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
     spv.Return
   }
 
   // CHECK-LABEL: @calling_loop_no_ret_func
   spv.func @calling_loop_no_ret_func() "None" {
     // CHECK-NEXT: %[[TRUE:.*]] = spv.constant true
     %0 = spv.constant true
     // CHECK-NEXT: spv.loop
     // CHECK-NEXT:   spv.Branch ^bb1
     // CHECK-NEXT: ^bb1:
     // CHECK-NEXT:   spv.BranchConditional %[[TRUE]], ^bb2, ^bb4
     // CHECK-NEXT: ^bb2:
     // CHECK-NEXT:   spv.Branch ^bb3
     // CHECK-NEXT: ^bb3:
     // CHECK-NEXT:   spv.Branch ^bb1
     // CHECK-NEXT: ^bb4:
-    // CHECK-NEXT:   spv._merge
+    // CHECK-NEXT:   spv.mlir.merge
     spv.FunctionCall @callee(%0) : (i1) -> ()
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
^bb1: // pred: ^bb0
       // CHECK: [[STOREPTR:%.*]] = spv.AccessChain [[ADDRESS_ARG1]]
       %7 = spv.AccessChain %3[%1] : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>, i32
       // CHECK-NOT: spv.FunctionCall
       // CHECK: spv.AtomicIAdd "Device" "AcquireRelease" [[STOREPTR]], [[VAL]]
       // CHECK: spv.Branch
       spv.FunctionCall @atomic_add(%5, %7) : (i32, !spv.ptr<i32, StorageBuffer>) -> ()
       spv.Branch ^bb2
     ^bb2 : // 2 preds: ^bb0, ^bb1
-      spv._merge
+      spv.mlir.merge
     }
     // CHECK: spv.Return
     spv.Return
   }
   spv.func @atomic_add(%arg0: i32, %arg1: !spv.ptr<i32, StorageBuffer>) "None" {
     %0 = spv.AtomicIAdd "Device" "AcquireRelease" %arg1, %arg0 : !spv.ptr<i32, StorageBuffer>
     spv.Return
   }
   spv.EntryPoint "GLCompute" @inline_into_selection_region
   spv.ExecutionMode @inline_into_selection_region "LocalSize", 32, 1, 1
 }
 
 // TODO: Add tests for inlining structured control flow into
 // structured control flow.

mlir/test/Dialect/SPIRV/canonicalize.mlir

^else:
     spv.Store "Function" %3, %2 ["Aligned", 4]: i32
     spv.Branch ^merge
 
   ^then:
     spv.Store "Function" %3, %1 ["Aligned", 4]: i32
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 func @canonicalize_selection_op_vector_type(%cond: i1) -> () {
   %0 = spv.constant dense<[0, 1, 2]> : vector<3xi32>
^then:
     spv.Store "Function" %3, %1 ["Aligned", 8]:  vector<3xi32>
     spv.Branch ^merge
 
   ^else:
     spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 // Store to a different variables.
 func @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
^then:
     spv.Store "Function" %3, %1 ["Aligned", 8]:  vector<3xi32>
     spv.Branch ^merge
 
   ^else:
     spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 // A conditional block consists of more than 2 operations.
 func @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
^then:
     spv.Branch ^merge
 
   ^else:
     // CHECK: spv.Store "Function" %[[DST_VAR_1]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
     spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 // A control-flow goes into `^then` block from `^else` block.
 func @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
^then:
     spv.Branch ^merge
 
   ^else:
     // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
     spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^then
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 // `spv.Return` as a block terminator.
 func @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
^then:
     spv.Return
 
   ^else:
     // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
     spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
 // Different memory access attributes.
 func @cannot_canonicalize_selection_op_4(%cond: i1) -> () {
^then:
     spv.Branch ^merge
 
   ^else:
     // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
     spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
     spv.Branch ^merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }

mlir/test/Dialect/SPIRV/control-flow-ops.mlir

^continue:
     %val1 = spv.Load "Function" %var : i32
     %add = spv.IAdd %val1, %one : i32
     spv.Store "Function" %var, %add : i32
     // CHECK: spv.Branch ^bb1
     spv.Branch ^header
 
   // CHECK-NEXT: ^bb4:
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: @empty_region
 func @empty_region() -> () {
func @loop_with_control() -> () {
   spv.loop control(Unroll) {
   }
   return
 }
 
 // -----
 
 func @wrong_merge_block() -> () {
-  // expected-error @+1 {{last block must be the merge block with only one 'spv._merge' op}}
+  // expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}}
   spv.loop {
     spv.Return
   }
   return
 }
 
 // -----
 
 func @missing_entry_block() -> () {
   // expected-error @+1 {{must have an entry block branching to the loop header block}}
   spv.loop {
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 func @missing_header_block() -> () {
   // expected-error @+1 {{must have a loop header block branched from the entry block}}
   spv.loop {
   ^entry:
     spv.Branch ^merge
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 func @entry_should_branch_to_header() -> () {
   // expected-error @+1 {{entry block must only have one 'spv.Branch' op to the second block}}
   spv.loop {
   ^entry:
     spv.Branch ^merge
   ^header:
     spv.Branch ^merge
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 func @missing_continue_block() -> () {
   // expected-error @+1 {{requires a loop continue block branching to the loop header block}}
   spv.loop {
   ^entry:
     spv.Branch ^header
   ^header:
     spv.Branch ^merge
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 func @continue_should_branch_to_header() -> () {
   // expected-error @+1 {{second to last block must be the loop continue block that branches to the loop header block}}
   spv.loop {
   ^entry:
     spv.Branch ^header
   ^header:
     spv.Branch ^continue
   ^continue:
     spv.Branch ^merge
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 func @only_entry_and_continue_branch_to_header() -> () {
   // expected-error @+1 {{can only have the entry and loop continue block branching to the loop header block}}
   spv.loop {
   ^entry:
     spv.Branch ^header
   ^header:
     spv.Branch ^cont1
   ^cont1:
     spv.Branch ^header
   ^cont2:
     spv.Branch ^header
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv._merge
+// spv.mlir.merge
 //===----------------------------------------------------------------------===//
 
 func @merge() -> () {
   // expected-error @+1 {{expected parent op to be 'spv.selection' or 'spv.loop'}}
-  spv._merge
+  spv.mlir.merge
 }
 
 // -----
 
 func @only_allowed_in_last_block(%cond : i1) -> () {
   %zero = spv.constant 0: i32
   %one = spv.constant 1: i32
   %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
 
   spv.selection {
     spv.BranchConditional %cond, ^then, ^merge
 
   ^then:
     spv.Store "Function" %var, %one : i32
     // expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}}
-    spv._merge
+    spv.mlir.merge
 
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
 
   spv.Return
 }
 
 // -----
 
 func @only_allowed_in_last_block() -> () {
   %true = spv.constant true
   spv.loop {
     spv.Branch ^header
   ^header:
     spv.BranchConditional %true, ^body, ^merge
   ^body:
     // expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}}
-    spv._merge
+    spv.mlir.merge
   ^continue:
     spv.Branch ^header
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.Return
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @in_selection
 func @in_selection(%cond : i1) -> () {
   spv.selection {
     spv.BranchConditional %cond, ^then, ^merge
   ^then:
     // CHECK: spv.Return
     spv.Return
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // CHECK-LABEL: func @in_loop
 func @in_loop(%cond : i1) -> () {
   spv.loop {
     spv.Branch ^header
   ^header:
     spv.BranchConditional %cond, ^body, ^merge
   ^body:
     // CHECK: spv.Return
     spv.Return
   ^continue:
     spv.Branch ^header
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   spv.Return
 }
 
 // CHECK-LABEL: in_other_func_like_op
 func @in_other_func_like_op() {
   // CHECK: spv.Return
   spv.Return

 spv.module Logical GLSL450 {
   spv.func @in_nested_region(%cond: i1) -> (i32) "None" {
     spv.selection {
       spv.BranchConditional %cond, ^then, ^merge
     ^then:
       // expected-error @+1 {{cannot be used in functions returning value}}
       spv.Return
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
 
     %zero = spv.constant 0: i32
     spv.ReturnValue %zero: i32
   }
 }
 
 // -----

 func @in_selection(%cond : i1) -> (i32) {
   spv.selection {
     spv.BranchConditional %cond, ^then, ^merge
   ^then:
     %zero = spv.constant 0 : i32
     // CHECK: spv.ReturnValue
     spv.ReturnValue %zero : i32
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   %one = spv.constant 1 : i32
   spv.ReturnValue %one : i32
 }
 
 // CHECK-LABEL: func @in_loop
 func @in_loop(%cond : i1) -> (i32) {
   spv.loop {
     spv.Branch ^header
   ^header:
     spv.BranchConditional %cond, ^body, ^merge
   ^body:
     %zero = spv.constant 0 : i32
     // CHECK: spv.ReturnValue
     spv.ReturnValue %zero : i32
   ^continue:
     spv.Branch ^header
   ^merge:
-    spv._merge
+    spv.mlir.merge
   }
   %one = spv.constant 1 : i32
   spv.ReturnValue %one : i32
 }
 
 // CHECK-LABEL: in_other_func_like_op
 func @in_other_func_like_op(%arg: i32) -> i32 {
   // CHECK: spv.ReturnValue
spv.module Logical GLSL450 {
   spv.func @in_nested_region(%cond: i1) -> () "None" {
     spv.selection {
       spv.BranchConditional %cond, ^then, ^merge
     ^then:
       %cst = spv.constant 0: i32
       // expected-error @+1 {{op returns 1 value but enclosing function requires 0 results}}
       spv.ReturnValue %cst: i32
     ^merge:
-      spv._merge
+      spv.mlir.merge
     }
 
     spv.Return
   }
 }
 
 // -----
 
func @selection(%cond: i1) -> () {
   // CHECK: ^bb1
   ^then:
     spv.Store "Function" %var, %one : i32
     // CHECK: spv.Branch ^bb2
     spv.Branch ^merge
 
   // CHECK: ^bb2
   ^merge:
-    // CHECK-NEXT: spv._merge
-    spv._merge
+    // CHECK-NEXT: spv.mlir.merge
+    spv.mlir.merge
   }
 
   spv.Return
 }
 
 // -----
 
 func @selection(%cond: i1) -> () {
func @selection(%cond: i1) -> () {
   // CHECK: ^bb2
   ^else:
     spv.Store "Function" %var, %two : i32
     // CHECK: spv.Branch ^bb3
     spv.Branch ^merge
 
   // CHECK: ^bb3
   ^merge:
-    // CHECK-NEXT: spv._merge
-    spv._merge
+    // CHECK-NEXT: spv.mlir.merge
+    spv.mlir.merge
   }
 
   spv.Return
 }
 
 // -----
 
 // CHECK-LABEL: @empty_region
func @selection_with_control() -> () {
   spv.selection control(Flatten) {
   }
   return
 }
 
 // -----
 
 func @wrong_merge_block() -> () {
-  // expected-error @+1 {{last block must be the merge block with only one 'spv._merge' op}}
+  // expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}}
   spv.selection {
     spv.Return
   }
   return
 }
 
 // -----
 
 func @missing_entry_block() -> () {
   // expected-error @+1 {{must have a selection header block}}
   spv.selection {
-    spv._merge
+    spv.mlir.merge
   }
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.Unreachable