[mlir][spirv] NFC: expose builtin func op conversion pattern

[antiagainst]

Summary

This commit exposes the func op conversion pattern via a new
populateBuiltinFuncToSPIRVPatterns function from the standard
to SPIR-V conversion passs. This is structurally better given
that func op belongs to the builtin dialect. More importantly,
this makes the pattern reusable to other dialect to SPIR-V
dialect conversion as other dialect can well adopt builtin
func op instead of having its own. Besides, it's very common
to use func ops as test wrappers in lit tests, so test passes
will need to handle func ops too.

[merge_guards_bot]

Unit tests: pass. 62195 tests passed, 0 failed and 815 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h

SPIRVOpLowering(MLIRContext *context, SPIRVTypeConverter &typeConverter,
                   PatternBenefit benefit = 1)
       : OpConversionPattern<SourceOp>(context, benefit),
         typeConverter(typeConverter) {}
 
 protected:
   SPIRVTypeConverter &typeConverter;
 };
 
+/// Appends to a pattern list additional patterns for translating the builtin
+/// `func` op to the SPIR-V dialect. These patterns do not handle shader
+/// interface/ABI; they convert function parameters to be of SPIR-V allowed
+/// types.
+void populateBuiltinFuncToSPIRVPatterns(MLIRContext *context,
+                                        SPIRVTypeConverter &typeConverter,
+                                        OwningRewritePatternList &patterns);
+
 namespace spirv {
 class SPIRVConversionTarget : public ConversionTarget {
 public:
   /// Creates a SPIR-V conversion target for the given target environment.
   static std::unique_ptr<SPIRVConversionTarget> get(TargetEnvAttr targetEnv,
                                                     MLIRContext *context);
 
 private:

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.cpp

 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVLowering.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
-
-/// A simple pattern for rewriting function signature to convert arguments of
-/// functions to be of valid SPIR-V types.
-class FuncOpConversion final : public SPIRVOpLowering<FuncOp> {
-public:
-  using SPIRVOpLowering<FuncOp>::SPIRVOpLowering;
-
-  PatternMatchResult
-  matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const override;
-};
-
 /// A pass converting MLIR Standard operations into the SPIR-V dialect.
 class ConvertStandardToSPIRVPass
     : public ModulePass<ConvertStandardToSPIRVPass> {
   void runOnModule() override;
 };
 } // namespace
 
-PatternMatchResult
-FuncOpConversion::matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
-                                  ConversionPatternRewriter &rewriter) const {
-  auto fnType = funcOp.getType();
-  if (fnType.getNumResults()) {
-    return matchFailure();
-  }
-
-  TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
-  {
-    for (auto argType : enumerate(funcOp.getType().getInputs())) {
-      auto convertedType = typeConverter.convertType(argType.value());
-      if (!convertedType) {
-        return matchFailure();
-      }
-      signatureConverter.addInputs(argType.index(), convertedType);
-    }
-  }
-
-  rewriter.updateRootInPlace(funcOp, [&] {
-    funcOp.setType(rewriter.getFunctionType(
-        signatureConverter.getConvertedTypes(), llvm::None));
-    rewriter.applySignatureConversion(&funcOp.getBody(), signatureConverter);
-  });
-  return matchSuccess();
-}
-
 void ConvertStandardToSPIRVPass::runOnModule() {
   MLIRContext *context = &getContext();
   ModuleOp module = getModule();
 
   SPIRVTypeConverter typeConverter;
   OwningRewritePatternList patterns;
   populateStandardToSPIRVPatterns(context, typeConverter, patterns);
-  patterns.insert<FuncOpConversion>(context, typeConverter);
+  populateBuiltinFuncToSPIRVPatterns(context, typeConverter, patterns);
 
   std::unique_ptr<ConversionTarget> target = spirv::SPIRVConversionTarget::get(
       spirv::lookupTargetEnvOrDefault(module), context);
   target->addDynamicallyLegalOp<FuncOp>(
       [&](FuncOp op) { return typeConverter.isSignatureLegal(op.getType()); });
 
   if (failed(applyPartialConversion(module, *target, patterns))) {
     return signalPassFailure();

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

return spirv::ArrayType::get(elementType,
                                  elementSize.getValue());
   }
   return Type();
 }
 
 Type SPIRVTypeConverter::convertType(Type type) { return convertStdType(type); }
 
 //===----------------------------------------------------------------------===//
+// FuncOp Conversion Patterns
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// A pattern for rewriting function signature to convert arguments of functions
+/// to be of valid SPIR-V types.
+class FuncOpConversion final : public SPIRVOpLowering<FuncOp> {
+public:
+  using SPIRVOpLowering<FuncOp>::SPIRVOpLowering;
+
+  PatternMatchResult
+  matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override;
+};
+} // namespace
+
+PatternMatchResult
+FuncOpConversion::matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+                                  ConversionPatternRewriter &rewriter) const {
+  auto fnType = funcOp.getType();
+  if (fnType.getNumResults())
+    return matchFailure();
+
+  TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
+  for (auto argType : enumerate(funcOp.getType().getInputs())) {
+    auto convertedType = typeConverter.convertType(argType.value());
+    if (!convertedType)
+      return matchFailure();
+    signatureConverter.addInputs(argType.index(), convertedType);
+  }
+
+  rewriter.updateRootInPlace(funcOp, [&] {
+    funcOp.setType(rewriter.getFunctionType(
+        signatureConverter.getConvertedTypes(), llvm::None));
+    rewriter.applySignatureConversion(&funcOp.getBody(), signatureConverter);
+  });
+
+  return matchSuccess();
+}
+
+void mlir::populateBuiltinFuncToSPIRVPatterns(
+    MLIRContext *context, SPIRVTypeConverter &typeConverter,
+    OwningRewritePatternList &patterns) {
+  patterns.insert<FuncOpConversion>(context, typeConverter);
+}
+
+//===----------------------------------------------------------------------===//
 // Builtin Variables
 //===----------------------------------------------------------------------===//
 
 /// Look through all global variables in `moduleOp` and check if there is a
 /// spv.globalVariable that has the same `builtin` attribute.
 static spirv::GlobalVariableOp getBuiltinVariable(spirv::ModuleOp &moduleOp,
                                                   spirv::BuiltIn builtin) {
   for (auto varOp : moduleOp.getBlock().getOps<spirv::GlobalVariableOp>()) {