[InsertPipelinePragma] imple of this pass; support to specify the insertion level

include/Transforms/Passes.h

@@ -19,6 +19,7 @@ std::unique_ptr<mlir::Pass> createPragmaDSEPass();
 std::unique_ptr<mlir::Pass> createAffineLoopPerfectionPass();
 std::unique_ptr<mlir::Pass> createPartialAffineLoopTilePass();
 std::unique_ptr<mlir::Pass> createRemoveVarLoopBoundPass();
+std::unique_ptr<mlir::Pass> createInsertPipelinePragmaPass();
 
 void registerTransformsPasses();
 

include/Transforms/Passes.td

@@ -20,6 +20,21 @@ def PragmaDSE : Pass<"pragma-dse", "ModuleOp"> {
   let constructor = "mlir::scalehls::createPragmaDSEPass()";
 }
 
+def InsertPipelinePragma : Pass<"insert-pipeline-pragma", "ModuleOp"> {
+  let summary = "Insert pipeline pragma";
+  let description = [{
+    This insert-pipeline-pragma pass will insert pipeline pragma to the
+    innermost loop level.
+  }];
+
+  let constructor = "mlir::scalehls::createInsertPipelinePragmaPass()";
+
+  let options = [
+    Option<"insertLevel", "insert-level", "unsigned", /*default=*/"1", 
+           "Positive number: loop level to be pipelined (from innermost)">
+  ];
+}
+
 def AffineLoopPerfection : Pass<"affine-loop-perfection", "ModuleOp"> {
   let summary = "Try to perfect a nested loop";
   let description = [{
@@ -43,7 +58,7 @@ def PartialAffineLoopTile : Pass<"partial-affine-loop-tile", "ModuleOp"> {
 
   let constructor = "mlir::scalehls::createPartialAffineLoopTilePass()";
 
-    let options = [
+  let options = [
     Option<"tileLevel", "tile-level", "unsigned", /*default=*/"1", 
            "Positive number: the level of loops to be tiles">,
     Option<"tileSize", "tile-size", "unsigned", /*default=*/"2", 

lib/Transforms/InsertPipelinePragma.cpp

@@ -0,0 +1,43 @@
+//===------------------------------------------------------------*- C++ -*-===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "Transforms/Passes.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Affine/Passes.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/Transforms/LoopUtils.h"
+
+using namespace std;
+using namespace mlir;
+using namespace scalehls;
+
+namespace {
+struct InsertPipelinePragma
+    : public InsertPipelinePragmaBase<InsertPipelinePragma> {
+  void runOnOperation() override;
+};
+} // namespace
+
+void InsertPipelinePragma::runOnOperation() {
+  auto module = getOperation();
+  auto builder = OpBuilder(module);
+
+  // Walk through all functions and loops.
+  for (auto func : module.getOps<FuncOp>()) {
+    for (auto forOp : func.getOps<mlir::AffineForOp>()) {
+      SmallVector<mlir::AffineForOp, 4> nestedLoops;
+      getPerfectlyNestedLoops(nestedLoops, forOp);
+
+      auto targetLoop = nestedLoops.front();
+      if (nestedLoops.size() > insertLevel)
+        targetLoop = *std::prev(nestedLoops.end(), insertLevel);
+
+      targetLoop.setAttr("pipeline", builder.getBoolAttr(true));
+    }
+  }
+}
+
+std::unique_ptr<mlir::Pass> scalehls::createInsertPipelinePragmaPass() {
+  return std::make_unique<InsertPipelinePragma>();
+}

test/Transforms/test_insert_pipeline_pragma.mlir

@@ -0,0 +1,6 @@
+// RUN: scalehls-opt -insert-pipeline-pragma %s | FileCheck %s
+
+// CHECK-LABEL: func @test_for
+func @test_for() {
+  return
+}