[MLIR][SPIRV] ModuleCombiner: deduplicate global vars, spec consts, and funcs.

[ergawy]

Summary

This commit extends the functionality of the SPIR-V module combiner
library by adding new deduplication capabilities. In particular,
implementation of deduplication of global variables and specialization
constants, and functions is introduced.

For global variables, 2 variables are considered duplicate if they either
have the same descriptor set + binding or the same built_in attribute.

For specialization constants, 2 spec constants are considered duplicate if
they have the same spec_id attribute.

2 functions are deduplicated if they are identical. 2 functions are
identical if they have the same prototype, attributes, and body.

[ergawy]

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

128

As mentioned already on an abandoned review (copied in order not to be lost):

This is a partial copy of BlockEquivalenceData from here: https://github.com/llvm/llvm-project/blob/474f7639e3494d9605f4444b087f48e710fbb0d4/mlir/lib/Transforms/Utils/RegionUtils.cpp#L374. I only copied the bare minimum needed for what I want to do in this patch.

However, I think it would be great if the original (not this stolen adaptation :) ) BlockEquivalenceData be put in some util header file accessible outside RegionUtils.cpp.

[ergawy]

Rebase

[ergawy]

Some minor re-formatting.

[ergawy]

Rebase.

[antiagainst]

Looks awesome, thanks!

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

76

Computes

90

We also need to consider the type and other potential attributes here. (Actually type is represented as an attribute on the op. so essentially we need to look at all attributes except the name.)

109

Computes

114

Also need to consider type and other potential attributes

128

Is there a need to keep the BlockEquivalenceData structure? I think we can just make this as a computeHash function?

131

I think the default OperationEquivalence::computeHash does not consider regions? So it will be problematic for operations like spv.loop/etc. We probably need to enhance OperationEquivalence::computeHash to support regions. For now, feel free to directly return hash 0 for ops with regions. We can handle them in a following up patch.

135

Computes

273

SmallVector<.., 0>?

277

symbolOp = dyn_cast<SymbolOpInterface>(op);

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir

50

This isn't correct. Two different entry points are basically two different kernels. So they are allowed to point to the same (set, binding) but with different types.

[ergawy]

Handle review comments.

[ergawy]

Handle further comments.

[ergawy]

Thanks for taking the time to review.

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

128

I left to bring attention to the fact that this is a partial copy of the original structure with the same name. To make things cleaner, I will do as you suggested and add a TODO to check if we can extract the original utility to some common header file.

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir

50

I changed the implementation so that such situation maintains the 2 variables without producing an error. Just a side question, should we validate an spv module to make sure that the 2 variables are not referenced by call graph rooted at a any of the entry points? I think such situation should result in the module being invalid, right?

[antiagainst]

Awesome, just one final nit.

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

107

We should just directly return if the op contains regions?

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir

50

Actually even for the some entry point, you can access two different global variables bound to the same (set, binding) pair. It's a way to alias. It's allowed.

[ergawy]

• Handle review comment.
• Rebase.

[ergawy]

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

107

Absolutely, if there are regions, with the current logic we might get false positives if 2 block match in all ops except for the region-containing ones.

[ergawy]

• Add missing check in deduplication code.

[antiagainst]

Awesome. Thanks a lot for this!

mlir/include/mlir/Dialect/SPIRV/ModuleCombiner.h

 namespace spirv {
 class ModuleOp;
 
 /// To combine a number of MLIR SPIR-V modules, we move all the module-level ops
 /// from all the input modules into one big combined module. To that end, the
 /// combination process proceeds in 2 phases:
 ///
 ///   (1) resolve conflicts between pairs of ops from different modules
-///   (2) deduplicate equivalent ops/sub-ops in the merged module. (TODO)
+///   (2) deduplicate equivalent ops/sub-ops in the merged module.
 ///
 /// For the conflict resolution phase, the following rules are employed to
 /// resolve such conflicts:
 ///
 ///   - If 2 spv.func's have the same symbol name, then rename one of the
 ///   functions.
 ///   - If an spv.func and another op have the same symbol name, then rename the
 ///   other symbol.
 ///   - If none of the 2 conflicting ops are spv.func, then rename either.
 ///
-/// In all cases, the references to the updated symbol are also updated to
-/// reflect the change.
+/// For deduplication, the following 3 cases are taken into consideration:
+///
+///   - If 2 spv.globalVariable's have either the same descriptor set + binding
+///   or the same build_in attribute value, then replace one of them using the
+///   other.
+///   - If 2 spv.specConstant's have the same spec_id attribute value, then
+///   replace one of them using the other.
+///   - If 2 spv.func's are identical replace one of them using the other.
+///
+/// In all cases, the references to the updated symbol (whether renamed or
+/// deduplicated) are also updated to reflect the change.
 ///
 /// \param modules the list of modules to combine. Input modules are not
 /// modified.
 /// \param combinedMdouleBuilder an OpBuilder to be used for
-/// building up the combined module.
+//                               building up the combined module.
 /// \param symbRenameListener a listener that gets called everytime a symbol in
 ///                           one of the input modules is renamed. The arguments
 ///                           passed to the listener are: the input
 ///                           spirv::ModuleOp that contains the renamed symbol,
 ///                           a StringRef to the old symbol name, and a
 ///                           StringRef to the new symbol name. Note that it is
 ///                           the responsibility of the caller to properly
 ///                           retain the storage underlying the passed

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

 //===- ModuleCombiner.cpp - MLIR SPIR-V Module Combiner ---------*- 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 implements the the SPIR-V module combiner library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/ModuleCombiner.h"
 
+#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace mlir;
 
 static constexpr unsigned maxFreeID = 1 << 20;
 
 static SmallString<64> renameSymbol(StringRef oldSymName, unsigned &lastUsedID,
                                     spirv::ModuleOp combinedModule) {
static LogicalResult updateSymbolAndAllUses(SymbolOpInterface op,
   if (failed(SymbolTable::replaceAllSymbolUses(op, newSymName, target)))
     return op.emitError("unable to update all symbol uses for ")
            << oldSymName << " to " << newSymName;
 
   SymbolTable::setSymbolName(op, newSymName);
   return success();
 }
 
+template <typename KeyTy, typename SymbolOpTy>
+static SymbolOpTy emplaceOrGetReplacementSymbolName(
+    KeyTy key, SymbolOpTy symbolOp,
+    DenseMap<KeyTy, SymbolOpTy> &deduplicationMap) {
+  auto result = deduplicationMap.try_emplace(key, symbolOp);
+
+  if (result.second)
+    return SymbolOpTy();
+
+  return result.first->second;
+}
+
+/// Compute a hash code to represent the argument GlobalVariableOp based on
+/// either:
+///
+/// - the global variable's descriptor set + binding,
+/// - or its built_in attribute value.
+///
+/// \return the hash code computed from either of the above attributes or 0 of
+/// the argument has neither.
+///
+/// Note: In this and the following 2 functions, we use the operation's name
+/// (not the symbol name) as part of the hash computation. This prevents, for
+/// example, mistakenly considering a global variable and a spec constant as
+/// duplicates because their descriptor set + binding and spec_id, repectively,
+/// happen to hash to the same value.
+static llvm::hash_code computeHash(spirv::GlobalVariableOp globalVarOp) {
+  IntegerAttr descriptorSet = globalVarOp.getAttrOfType<IntegerAttr>(
+      spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet));
+  IntegerAttr binding = globalVarOp.getAttrOfType<IntegerAttr>(
+      spirv::SPIRVDialect::getAttributeName(spirv::Decoration::Binding));
+
+  if (descriptorSet)
+    return llvm::hash_combine(globalVarOp.getOperation()->getName(),
+                              descriptorSet, binding);
+
+  StringAttr builtIn = globalVarOp.getAttrOfType<StringAttr>(
+      spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn));
+
+  if (builtIn)
+    return llvm::hash_combine(builtIn);
+
+  return 0;
+}
+
+/// Compute the hash code to represent the argument SpecConstantOp based on
+/// whether it has a spec_id attribute.
+///
+/// \return a hash code based on spec_id or 0 if the argument doesn't have such
+/// attribute.
+static llvm::hash_code computeHash(spirv::SpecConstantOp specConstOp) {
+  IntegerAttr specId = specConstOp.getAttrOfType<IntegerAttr>(
+      spirv::SPIRVDialect::getAttributeName(spirv::Decoration::SpecId));
+  return specId
+             ? llvm::hash_combine(specConstOp.getOperation()->getName(), specId)
+             : llvm::hash_code(0);
+}
+
+struct BlockEquivalenceData {
+  BlockEquivalenceData(Block *block);
+
+  llvm::hash_code hash;
+};
+
+BlockEquivalenceData::BlockEquivalenceData(Block *block) : hash(0) {
+  for (Operation &op : *block) {
+    hash = llvm::hash_combine(
+        hash, OperationEquivalence::computeHash(
+                  &op, OperationEquivalence::Flags::IgnoreOperands));
+  }
+}
+
+/// Compute the hash code to represent the argument FuncOp based on the
+/// functions prototype, attributes, and body (i.e. its blocks and their
+/// operations).
+static llvm::hash_code computeHash(spirv::FuncOp funcOp) {
+  llvm::hash_code hashCode(0);
+  hashCode = llvm::hash_combine(funcOp.getOperation()->getName());
+
+  for (auto attr : funcOp.getOperation()->getAttrs()) {
+    if (attr.first == SymbolTable::getSymbolAttrName())
+      continue;
+    hashCode = llvm::hash_combine(hashCode, attr);
+  }
+
+  for (auto &blk : funcOp) {
+    hashCode = llvm::hash_combine(hashCode, BlockEquivalenceData(&blk).hash);
+  }
+
+  return hashCode;
+}
+
 namespace mlir {
 namespace spirv {
 
 // TODO Properly test symbol rename listener mechanism.
 
 OwningSPIRVModuleRef
 combine(llvm::MutableArrayRef<spirv::ModuleOp> modules,
         OpBuilder &combinedModuleBuilder,
for (auto &op : moduleClone.getBlock().without_terminator()) {
       }
     }
 
     // Clone all the module's ops to the combined module.
     for (auto &op : moduleClone.getBlock().without_terminator())
       combinedModuleBuilder.insert(op.clone());
   }
 
+  // Deduplicate identical global variables, spec constants, and functions.
+  DenseMap<llvm::hash_code, SymbolOpInterface> hashToSymbolOp;
+  std::vector<SymbolOpInterface> eraseList;
+
+  for (auto &op : combinedModule.getBlock().without_terminator()) {
+    llvm::hash_code hashCode(0);
+    SymbolOpInterface symbolOp;
+
+    if (!(symbolOp = dyn_cast<SymbolOpInterface>(op)))
+      continue;
+
+    if (auto globalVarOp = dyn_cast<GlobalVariableOp>(op))
+      hashCode = computeHash(globalVarOp);
+    else if (auto specConstOp = dyn_cast<SpecConstantOp>(op))
+      hashCode = computeHash(specConstOp);
+    else if (auto funcOp = dyn_cast<FuncOp>(op))
+      hashCode = computeHash(funcOp);
+
+    // 0 hash means the operations doesn't contain the neccessary information
+    // (i.e. attributes) needed to check for duplication with similar ops.
+    if (!hashCode)
+      continue;
+
+    SymbolOpInterface replacementSymOp =
+        emplaceOrGetReplacementSymbolName(hashCode, symbolOp, hashToSymbolOp);
+
+    if (!replacementSymOp)
+      continue;
+
+    if (failed(SymbolTable::replaceAllSymbolUses(
+            symbolOp, replacementSymOp.getName(), combinedModule))) {
+
+      symbolOp.emitError("unable to update all symbol uses for ")
+          << symbolOp.getName() << " to " << replacementSymOp.getName();
+      return nullptr;
+    }
+
+    eraseList.push_back(symbolOp);
+  }
+
+  for (auto symbolOp : eraseList)
+    symbolOp.erase();
+
   return combinedModule;
 }
 
 } // namespace spirv
 } // namespace mlir

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict_resolution.mlir

 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo_1
+// CHECK-NEXT:       spv.FAdd
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo_2
+// CHECK-NEXT:       spv.ISub
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : f32) -> f32 "None" {
-    spv.ReturnValue %arg0 : f32
+    %0 = spv.FAdd %arg0, %arg0 : f32
+    spv.ReturnValue %0 : f32
   }
 }
 
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
-    spv.ReturnValue %arg0 : i32
+    %0 = spv.ISub %arg0, %arg0 : i32
+    spv.ReturnValue %0 : i32
   }
 }
 }
 
 // -----
 
 // Test properly updating references to a renamed funcOp.
 

 }
 
 // -----
 
 // Resolve conflicting globalVariableOps.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.globalVariable @foo_1
+// CHECK-NEXT:     spv.globalVariable @foo_1 bind(1, 0)
 
-// CHECK-NEXT:     spv.globalVariable @foo
+// CHECK-NEXT:     spv.globalVariable @foo bind(2, 0)
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
 }
 
 spv.module Logical GLSL450 {
-  spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
+  spv.globalVariable @foo bind(2, 0) : !spv.ptr<f32, Input>
+}
+}
+
+// -----
+
+// CHECK:      module {
+// CHECK-NEXT:   spv.module Logical GLSL450 {
+// CHECK-NEXT:     spv.globalVariable @foo_1 built_in("GlobalInvocationId")
+
+// CHECK-NEXT:     spv.globalVariable @foo built_in("LocalInvocationId")
+// CHECK-NEXT: }
+
+module {
+spv.module Logical GLSL450 {
+  spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
+}
+
+spv.module Logical GLSL450 {
+  spv.globalVariable @foo built_in("LocalInvocationId") : !spv.ptr<vector<3xi32>, Input>
 }
 }
 
 // -----
 
 // Resolve conflicting globalVariableOp and specConstantOp.
 
 // CHECK:      module {

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir

+// RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s
+
+// Deduplicate 2 global variables with the same descriptor set and binding.
+
+// CHECK:      module {
+// CHECK-NEXT:   spv.module Logical GLSL450 {
+// CHECK-NEXT:     spv.globalVariable @foo
+
+// CHECK-NEXT:     spv.func @use_foo
+// CHECK-NEXT:       spv._address_of @foo
+// CHECK-NEXT:       spv.Load
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @use_bar
+// CHECK-NEXT:       spv._address_of @foo
+// CHECK-NEXT:       spv.Load
+// CHECK-NEXT:       spv.FAdd
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: }
+
+module {
+spv.module Logical GLSL450 {
+  spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
+
+  spv.func @use_foo() -> f32 "None" {
+    %0 = spv._address_of @foo : !spv.ptr<f32, Input>
+    %1 = spv.Load "Input" %0 : f32
+    spv.ReturnValue %1 : f32
+  }
+}
+
+spv.module Logical GLSL450 {
+  spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input>
+
+  spv.func @use_bar() -> f32 "None" {
+    %0 = spv._address_of @bar : !spv.ptr<f32, Input>
+    %1 = spv.Load "Input" %0 : f32
+    %2 = spv.FAdd %1, %1 : f32
+    spv.ReturnValue %2 : f32
+  }
+}
+}
+
+// -----
+
+// Deduplicate 2 global variables with the same descriptor set and binding but different types.
+
+module {
+spv.module Logical GLSL450 {
+  spv.globalVariable @foo bind(1, 0) : !spv.ptr<i32, Input>
+}
+
+spv.module Logical GLSL450 {
+  spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input>
+
+  spv.func @use_bar() -> f32 "None" {
+    // expected-error @+1 {{result type mismatch with the referenced global variable's type}}
+    %0 = spv._address_of @bar : !spv.ptr<f32, Input>
+    %1 = spv.Load "Input" %0 : f32
+    spv.ReturnValue %1 : f32
+  }
+}
+}
+
+// -----
+
+// Deduplicate 2 global variables with the same built-in attribute.
+
+// CHECK:      module {
+// CHECK-NEXT:   spv.module Logical GLSL450 {
+// CHECK-NEXT:     spv.globalVariable @foo built_in("GlobalInvocationId")
+// CHECK-NEXT:     spv.func @use_bar
+// CHECK-NEXT:       spv._address_of @foo
+// CHECK-NEXT:       spv.Load
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: }
+
+module {
+spv.module Logical GLSL450 {
+  spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
+}
+
+spv.module Logical GLSL450 {
+  spv.globalVariable @bar built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
+
+  spv.func @use_bar() -> vector<3xi32> "None" {
+    %0 = spv._address_of @bar : !spv.ptr<vector<3xi32>, Input>
+    %1 = spv.Load "Input" %0 : vector<3xi32>
+    spv.ReturnValue %1 : vector<3xi32>
+  }
+}
+}
+
+// -----
+
+// CHECK:      module {
+// CHECK-NEXT:   spv.module Logical GLSL450 {
+// CHECK-NEXT:     spv.specConstant @foo spec_id(5)
+
+// CHECK-NEXT:     spv.func @use_foo()
+// CHECK-NEXT:       %0 = spv._reference_of @foo
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @use_bar()
+// CHECK-NEXT:       %0 = spv._reference_of @foo
+// CHECK-NEXT:       spv.FAdd
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: }
+
+module {
+spv.module Logical GLSL450 {
+  spv.specConstant @foo spec_id(5) = 1. : f32
+
+  spv.func @use_foo() -> (f32) "None" {
+    %0 = spv._reference_of @foo : f32
+    spv.ReturnValue %0 : f32
+  }
+}
+
+spv.module Logical GLSL450 {
+  spv.specConstant @bar spec_id(5) = 1. : f32
+
+  spv.func @use_bar() -> (f32) "None" {
+    %0 = spv._reference_of @bar : f32
+    %1 = spv.FAdd %0, %0 : f32
+    spv.ReturnValue %1 : f32
+  }
+}
+}
+
+// -----
+
+// CHECK:      module {
+// CHECK-NEXT:   spv.module Logical GLSL450 {
+// CHECK-NEXT:     spv.specConstant @bar spec_id(5)
+
+// CHECK-NEXT:     spv.func @foo(%arg0: f32)
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @foo_different_body(%arg0: f32)
+// CHECK-NEXT:       spv._reference_of
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @baz(%arg0: i32)
+// CHECK-NEXT:       spv.ReturnValue
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @baz_no_return(%arg0: i32)
+// CHECK-NEXT:       spv.Return
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @baz_no_return_different_control
+// CHECK-NEXT:       spv.Return
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @baz_no_return_another_control
+// CHECK-NEXT:       spv.Return
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @kernel
+// CHECK-NEXT:       spv.Return
+// CHECK-NEXT:     }
+
+// CHECK-NEXT:     spv.func @kernel_different_attr
+// CHECK-NEXT:       spv.Return
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT:   }
+
+module {
+spv.module Logical GLSL450 {
+  spv.specConstant @bar spec_id(5) = 1. : f32
+
+  spv.func @foo(%arg0: f32) -> (f32) "None" {
+    spv.ReturnValue %arg0 : f32
+  }
+
+  spv.func @foo_duplicate(%arg0: f32) -> (f32) "None" {
+    spv.ReturnValue %arg0 : f32
+  }
+
+  spv.func @foo_different_body(%arg0: f32) -> (f32) "None" {
+    %0 = spv._reference_of @bar : f32
+    spv.ReturnValue %arg0 : f32
+  }
+
+  spv.func @baz(%arg0: i32) -> (i32) "None" {
+    spv.ReturnValue %arg0 : i32
+  }
+
+  spv.func @baz_no_return(%arg0: i32) "None" {
+    spv.Return
+  }
+
+  spv.func @baz_no_return_duplicate(%arg0: i32) -> () "None" {
+    spv.Return
+  }
+
+  spv.func @baz_no_return_different_control(%arg0: i32) -> () "Inline" {
+    spv.Return
+  }
+
+  spv.func @baz_no_return_another_control(%arg0: i32) -> () "Inline|Pure" {
+    spv.Return
+  }
+
+  spv.func @kernel(
+    %arg0: f32,
+    %arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "None"
+  attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} {
+    spv.Return
+  }
+
+  spv.func @kernel_different_attr(
+    %arg0: f32,
+    %arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "None"
+  attributes {spv.entry_point_abi = {local_size = dense<[64, 1, 1]> : vector<3xi32>}} {
+    spv.Return
+  }
+}
+}