[mlir][AffineToStandard] Make LowerAffine pass Op-agnostic.

[mravishankar]

Summary

The LowerAffine psas was a FunctionPass only for legacy
reasons. Making this Op-agnostic allows it to be used from command
line when affine expressions are within operations other than
std.func.

[bondhugula]

Thanks @mravishankar - could you please add a test case (a trivial one should suffice)?

[mravishankar]

Adding test case

[mravishankar]

Added a test case.

[bondhugula]

mlir/include/mlir/Conversion/Passes.td

23

This comment is outdated. loop -> SCF.

mlir/test/Conversion/AffineToStandard/lower-affine-gpu.mlir

15

Nit: indent load please.

[mravishankar]

Addressing comments and rebase

mlir/include/mlir/Conversion/Passes.td

 #define MLIR_CONVERSION_PASSES
 
 include "mlir/Pass/PassBase.td"
 
 //===----------------------------------------------------------------------===//
 // AffineToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertAffineToStandard : FunctionPass<"lower-affine"> {
+def ConvertAffineToStandard : Pass<"lower-affine"> {
   let summary = "Lower Affine operations to a combination of Standard and SCF "
                 "operations";
   let description = [{
 
-    Convert operations from the affine dialect into operations from the loop and
+    Convert operations from the affine dialect into operations from the SCF and
     standard dialects.
 
     `affine.for` operations are converted to `scf.for` operations that are free
     of certain structural restrictions (on their bounds and step). `affine.if`
     is similarly converted to the `scf.if` operation. `affine.apply` operations
     are converted into sequences of primitive arithmetic operations from the
     standard dialect that have the same effect, using operands of the `index`
     type. Consequently, named maps and sets thare are no longer in use may be

mlir/include/mlir/Transforms/Passes.h

 
 /// Creates a pass to pipeline explicit movement of data across levels of the
 /// memory hierarchy.
 std::unique_ptr<OperationPass<FuncOp>> createPipelineDataTransferPass();
 
 /// Lowers affine control flow operations (ForStmt, IfStmt and AffineApplyOp)
 /// to equivalent lower-level constructs (flow of basic blocks and arithmetic
 /// primitives).
-std::unique_ptr<OperationPass<FuncOp>> createLowerAffinePass();
+std::unique_ptr<Pass> createLowerAffinePass();
 
 /// Creates a pass that transforms perfectly nested loops with independent
 /// bounds into a single loop.
 std::unique_ptr<OperationPass<FuncOp>> createLoopCoalescingPass();
 
 /// Creates a pass that transforms a single ParallelLoop over N induction
 /// variables into another ParallelLoop over less than N induction variables.
 std::unique_ptr<Pass> createParallelLoopCollapsingPass();

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

void mlir::populateAffineToVectorConversionPatterns(
   patterns.insert<
       AffineVectorLoadLowering,
       AffineVectorStoreLowering>(ctx);
   // clang-format on
 }
 
 namespace {
 class LowerAffinePass : public ConvertAffineToStandardBase<LowerAffinePass> {
-  void runOnFunction() override {
+  void runOnOperation() override {
     OwningRewritePatternList patterns;
     populateAffineToStdConversionPatterns(patterns, &getContext());
     populateAffineToVectorConversionPatterns(patterns, &getContext());
     ConversionTarget target(getContext());
     target
         .addLegalDialect<scf::SCFDialect, StandardOpsDialect, VectorDialect>();
-    if (failed(applyPartialConversion(getFunction(), target, patterns)))
+    if (failed(applyPartialConversion(getOperation(), target, patterns)))
       signalPassFailure();
   }
 };
 } // namespace
 
 /// Lowers If and For operations within a function into their lower level CFG
 /// equivalent blocks.
-std::unique_ptr<OperationPass<FuncOp>> mlir::createLowerAffinePass() {
+std::unique_ptr<Pass> mlir::createLowerAffinePass() {
   return std::make_unique<LowerAffinePass>();
 }

mlir/test/Conversion/AffineToStandard/lower-affine-gpu.mlir

+// RUN: mlir-opt -pass-pipeline="gpu.module(lower-affine)" %s | FileCheck %s
+
+#map0gpufunc = affine_map<(d0) -> (d0)>
+gpu.module @kernels {
+  gpu.func @foo(%arg0 : index, %arg1 : memref<?xf32>) -> f32 {
+    %0 = affine.apply #map0gpufunc(%arg0)
+    %1 = load %arg1[%0] : memref<?xf32>
+    gpu.return %1 : f32
+  }
+
+//      CHECK: gpu.func
+// CHECK-SAME: %[[ARG0:.*]]: index
+//  CHECK-NOT:   affine.apply
+//      CHECK:   load %{{.*}}[%[[ARG0]]]
+}