[MooreToCore] Convert SCF ops inside llhd.process to CF

llvm · Feb 3, 2025 · 266b59e · 266b59e
1 parent 5aa1cc3
commit 266b59e
Show file tree

Hide file tree

Showing 5 changed files with 52 additions and 22 deletions.
diff --git a/include/circt/Transforms/Passes.h b/include/circt/Transforms/Passes.h
@@ -36,6 +36,9 @@ enum class OpCountEmissionFormat {
 
 #include "circt/Transforms/Passes.h.inc"
 
+void populateArithToCombPatterns(mlir::RewritePatternSet &patterns,
+                                 TypeConverter &typeConverter);
+
 std::unique_ptr<mlir::Pass> createMapArithToCombPass();
 std::unique_ptr<mlir::Pass> createFlattenMemRefPass();
 std::unique_ptr<mlir::Pass> createFlattenMemRefCallsPass();

diff --git a/lib/Conversion/MooreToCore/CMakeLists.txt b/lib/Conversion/MooreToCore/CMakeLists.txt
@@ -15,9 +15,11 @@ add_circt_conversion_library(CIRCTMooreToCore
   CIRCTMoore
   CIRCTSim
   CIRCTVerif
+  CIRCTTransforms
   MLIRControlFlowDialect
   MLIRFuncDialect
   MLIRSCFDialect
+  MLIRSCFToControlFlow
   MLIRSideEffectInterfaces
   MLIRTransforms
 )
diff --git a/lib/Conversion/MooreToCore/MooreToCore.cpp b/lib/Conversion/MooreToCore/MooreToCore.cpp
@@ -18,6 +18,8 @@
 #include "circt/Dialect/Moore/MooreOps.h"
 #include "circt/Dialect/Sim/SimOps.h"
 #include "circt/Dialect/Verif/VerifOps.h"
+#include "circt/Transforms/Passes.h"
+#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
@@ -1508,11 +1510,16 @@ static void populateLegality(ConversionTarget &target,
   target.addLegalOp<debug::ScopeOp>();
 
   target.addDynamicallyLegalOp<
-      cf::CondBranchOp, cf::BranchOp, scf::IfOp, scf::ForOp, scf::YieldOp,
-      func::CallOp, func::ReturnOp, UnrealizedConversionCastOp, hw::OutputOp,
-      hw::InstanceOp, debug::ArrayOp, debug::StructOp, debug::VariableOp>(
+      cf::CondBranchOp, cf::BranchOp, scf::YieldOp, func::CallOp,
+      func::ReturnOp, UnrealizedConversionCastOp, hw::OutputOp, hw::InstanceOp,
+      debug::ArrayOp, debug::StructOp, debug::VariableOp>(
       [&](Operation *op) { return converter.isLegal(op); });
 
+  target.addDynamicallyLegalOp<scf::IfOp, scf::ForOp, scf::ExecuteRegionOp,
+                               scf::WhileOp, scf::ForallOp>([&](Operation *op) {
+    return converter.isLegal(op) && !op->getParentOfType<llhd::ProcessOp>();
+  });
+
   target.addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
     return converter.isSignatureLegal(op.getFunctionType()) &&
            converter.isLegal(&op.getFunctionBody());
@@ -1738,6 +1745,8 @@ static void populateOpConversion(RewritePatternSet &patterns,
                                                             typeConverter);
   hw::populateHWModuleLikeTypeConversionPattern(
       hw::HWModuleOp::getOperationName(), patterns, typeConverter);
+  populateSCFToControlFlowConversionPatterns(patterns);
+  populateArithToCombPatterns(patterns, typeConverter);
 }
 
 //===----------------------------------------------------------------------===//

diff --git a/lib/Transforms/MapArithToComb.cpp b/lib/Transforms/MapArithToComb.cpp
@@ -163,25 +163,7 @@ struct MapArithToCombPass
     target.addIllegalDialect<arith::ArithDialect>();
     MapArithTypeConverter typeConverter;
     RewritePatternSet patterns(ctx);
-
-    patterns.insert<OneToOnePattern<arith::AddIOp, comb::AddOp>,
-                    OneToOnePattern<arith::SubIOp, comb::SubOp>,
-                    OneToOnePattern<arith::MulIOp, comb::MulOp>,
-                    OneToOnePattern<arith::DivSIOp, comb::DivSOp>,
-                    OneToOnePattern<arith::DivUIOp, comb::DivUOp>,
-                    OneToOnePattern<arith::RemSIOp, comb::ModSOp>,
-                    OneToOnePattern<arith::RemUIOp, comb::ModUOp>,
-                    OneToOnePattern<arith::AndIOp, comb::AndOp>,
-                    OneToOnePattern<arith::OrIOp, comb::OrOp>,
-                    OneToOnePattern<arith::XOrIOp, comb::XorOp>,
-                    OneToOnePattern<arith::ShLIOp, comb::ShlOp>,
-                    OneToOnePattern<arith::ShRSIOp, comb::ShrSOp>,
-                    OneToOnePattern<arith::ShRUIOp, comb::ShrUOp>,
-                    OneToOnePattern<arith::ConstantOp, hw::ConstantOp, true>,
-                    OneToOnePattern<arith::SelectOp, comb::MuxOp>,
-                    ExtSConversionPattern, ExtZConversionPattern,
-                    TruncateConversionPattern, CompConversionPattern>(
-        typeConverter, ctx);
+    populateArithToCombPatterns(patterns, typeConverter);
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
@@ -191,6 +173,28 @@ struct MapArithToCombPass
 
 } // namespace
 
+void circt::populateArithToCombPatterns(mlir::RewritePatternSet &patterns,
+                                        TypeConverter &typeConverter) {
+  patterns.insert<OneToOnePattern<arith::AddIOp, comb::AddOp>,
+                  OneToOnePattern<arith::SubIOp, comb::SubOp>,
+                  OneToOnePattern<arith::MulIOp, comb::MulOp>,
+                  OneToOnePattern<arith::DivSIOp, comb::DivSOp>,
+                  OneToOnePattern<arith::DivUIOp, comb::DivUOp>,
+                  OneToOnePattern<arith::RemSIOp, comb::ModSOp>,
+                  OneToOnePattern<arith::RemUIOp, comb::ModUOp>,
+                  OneToOnePattern<arith::AndIOp, comb::AndOp>,
+                  OneToOnePattern<arith::OrIOp, comb::OrOp>,
+                  OneToOnePattern<arith::XOrIOp, comb::XorOp>,
+                  OneToOnePattern<arith::ShLIOp, comb::ShlOp>,
+                  OneToOnePattern<arith::ShRSIOp, comb::ShrSOp>,
+                  OneToOnePattern<arith::ShRUIOp, comb::ShrUOp>,
+                  OneToOnePattern<arith::ConstantOp, hw::ConstantOp, true>,
+                  OneToOnePattern<arith::SelectOp, comb::MuxOp>,
+                  ExtSConversionPattern, ExtZConversionPattern,
+                  TruncateConversionPattern, CompConversionPattern>(
+      typeConverter, patterns.getContext());
+}
+
 std::unique_ptr<mlir::Pass> circt::createMapArithToCombPass() {
   return std::make_unique<MapArithToCombPass>();
 }
diff --git a/test/Conversion/MooreToCore/basic.mlir b/test/Conversion/MooreToCore/basic.mlir
@@ -1034,3 +1034,15 @@ func.func @PowSOp(%arg0: !moore.i32, %arg1: !moore.i32) {
   %0 = moore.pows %arg0, %arg1 : i32
   return
 }
+
+// CHECK-LABEL: @scfInsideProcess
+moore.module @scfInsideProcess(in %in0: !moore.i32, in %in1: !moore.i32) {
+  %var = moore.variable : <!moore.i32>
+  // CHECK: llhd.process
+  // CHECK-NOT: scf.for
+  moore.procedure initial {
+    %0 = moore.pows %in0, %in1 : !moore.i32
+    moore.blocking_assign %var, %0 : !moore.i32
+    moore.return
+  }
+}