[ArcToLLVM] Add arc.execute conversion (llvm#8951)

Add a conversion from `arc.execute` to the LLVM dialect. The conversion
mimics `scf.execute_region`, but tries to convert types and block
signatures along the way. (No idea why SCF does not do this.) This
allows `arc.execute` ops to be lowered to LLVM by inlining the control
flow graph into the parent SSACFG region, most likely an `llvm.func`.
This now allows Arcilator to simulate designs that contain
`llhd.combinational` ops.

Author: fabianschuiki

lib/Conversion/ArcToLLVM/LowerArcToLLVM.cpp

@@ -14,6 +14,7 @@
 #include "circt/Dialect/Arc/ModelInfo.h"
 #include "circt/Dialect/Comb/CombOps.h"
 #include "circt/Dialect/Seq/SeqOps.h"
+#include "circt/Support/ConversionPatternSet.h"
 #include "circt/Support/Namespace.h"
 #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
@@ -22,7 +23,7 @@
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
-#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
+#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Index/IR/IndexOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
@@ -598,6 +599,53 @@ struct SimEmitValueOpLowering
 
 } // namespace
 
+static LogicalResult convert(arc::ExecuteOp op, arc::ExecuteOp::Adaptor adaptor,
+                             ConversionPatternRewriter &rewriter,
+                             const TypeConverter &converter) {
+  // Convert the argument types in the body blocks.
+  if (failed(rewriter.convertRegionTypes(&op.getBody(), converter)))
+    return failure();
+
+  // Split the block at the current insertion point such that we can branch into
+  // the `arc.execute` body region, and have `arc.output` branch back to the
+  // point after the `arc.execute`.
+  auto *blockBefore = rewriter.getInsertionBlock();
+  auto *blockAfter =
+      rewriter.splitBlock(blockBefore, rewriter.getInsertionPoint());
+
+  // Branch to the entry block.
+  rewriter.setInsertionPointToEnd(blockBefore);
+  mlir::cf::BranchOp::create(rewriter, op.getLoc(), &op.getBody().front(),
+                             adaptor.getInputs());
+
+  // Make all `arc.output` terminators branch to the block after the
+  // `arc.execute` op.
+  for (auto &block : op.getBody()) {
+    auto outputOp = dyn_cast<arc::OutputOp>(block.getTerminator());
+    if (!outputOp)
+      continue;
+    rewriter.setInsertionPointToEnd(&block);
+    rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(outputOp, blockAfter,
+                                                    outputOp.getOperands());
+  }
+
+  // Inline the body region between the before and after blocks.
+  rewriter.inlineRegionBefore(op.getBody(), blockAfter);
+
+  // Add arguments to the block after the `arc.execute`, replace the op's
+  // results with the arguments, then perform block signature conversion.
+  SmallVector<Value> args;
+  args.reserve(op.getNumResults());
+  for (auto result : op.getResults())
+    args.push_back(blockAfter->addArgument(result.getType(), result.getLoc()));
+  rewriter.replaceOp(op, args);
+  auto conversion = converter.convertBlockSignature(blockAfter);
+  if (!conversion)
+    return failure();
+  rewriter.applySignatureConversion(blockAfter, *conversion, &converter);
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Pass Implementation
 //===----------------------------------------------------------------------===//
@@ -667,7 +715,7 @@ void LowerArcToLLVMPass::runOnOperation() {
   });
 
   // Setup the conversion patterns.
-  RewritePatternSet patterns(&getContext());
+  ConversionPatternSet patterns(&getContext(), converter);
 
   // MLIR patterns.
   populateSCFToControlFlowConversionPatterns(patterns);
@@ -708,6 +756,7 @@ void LowerArcToLLVMPass::runOnOperation() {
     ZeroCountOpLowering
   >(converter, &getContext());
   // clang-format on
+  patterns.add<ExecuteOp>(convert);
 
   SmallVector<ModelInfo> models;
   if (failed(collectModels(getOperation(), models))) {

test/Conversion/ArcToLLVM/lower-arc-to-llvm.mlir

@@ -243,3 +243,38 @@ func.func @DontCrashOnI0(%arg0: i1, %arg1: !hw.array<1xi42>) -> i42 {
   %1 = hw.array_get %arg1[%0] : !hw.array<1xi42>, i0
   return %1 : i42
 }
+
+// CHECK-LABEL: llvm.func @ExecuteEmpty
+func.func @ExecuteEmpty() {
+  // CHECK-NEXT: llvm.br [[BB:\^.+]]
+  // CHECK-NEXT: [[BB]]:
+  arc.execute {
+    // CHECK-NEXT: llvm.br [[BB:\^.+]]
+    arc.output
+  }
+  // CHECK-NEXT: [[BB]]:
+  // CHECK-NEXT: llvm.return
+  return
+}
+
+// CHECK-LABEL: llvm.func @ExecuteWithOperandsAndResults
+func.func @ExecuteWithOperandsAndResults(%arg0: i42, %arg1: !hw.array<4xi19>, %arg2: !arc.storage) {
+  // CHECK-NEXT: llvm.br [[BB:\^.+]](%arg0, %arg1, %arg2 : i42, !llvm.array<4 x i19>, !llvm.ptr)
+  // CHECK-NEXT: [[BB]]([[ARG0:%.+]]: i42, [[ARG1:%.+]]: !llvm.array<4 x i19>, [[ARG2:%.+]]: !llvm.ptr):
+  %4:3 = arc.execute (%arg0, %arg1, %arg2 : i42, !hw.array<4xi19>, !arc.storage) -> (i42, !hw.array<4xi19>, !arc.storage) {
+  ^bb0(%0: i42, %1: !hw.array<4xi19>, %2: !arc.storage):
+    // CHECK-NEXT: llvm.br [[BB:\^.+]]([[ARG2]] : !llvm.ptr)
+    cf.br ^bb1(%2 : !arc.storage)
+  ^bb1(%3: !arc.storage):
+    // CHECK-NEXT: [[BB]]([[ARG2:%.+]]: !llvm.ptr):
+    // CHECK-NEXT: llvm.br [[BB:\^.+]]([[ARG0]], [[ARG1]], [[ARG2]] : i42, !llvm.array<4 x i19>, !llvm.ptr)
+    arc.output %0, %1, %3 : i42, !hw.array<4xi19>, !arc.storage
+  }
+  // CHECK-NEXT: [[BB]]([[ARG0:%.+]]: i42, [[ARG1:%.+]]: !llvm.array<4 x i19>, [[ARG2:%.+]]: !llvm.ptr):
+  // CHECK-NEXT: llvm.call @Dummy([[ARG0:%.+]], [[ARG1:%.+]], [[ARG2:%.+]]) : (i42, !llvm.array<4 x i19>, !llvm.ptr) -> ()
+  call @Dummy(%4#0, %4#1, %4#2) : (i42, !hw.array<4xi19>, !arc.storage) -> ()
+  // CHECK-NEXT: llvm.return
+  return
+}
+
+func.func private @Dummy(%arg0: i42, %arg1: !hw.array<4xi19>, %arg2: !arc.storage)

tools/arcilator/arcilator.cpp

@@ -641,6 +641,7 @@ int main(int argc, char **argv) {
     // Dialect passes:
     arc::registerPasses();
     registerConvertToArcsPass();
+    registerLowerArcToLLVMPass();
   }
 
   // Register any pass manager command line options.