[CIR][ThroughMLIR] Support lowering cir.do to scf.while

Author: wenhu1024

clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp

@@ -69,6 +69,19 @@ class SCFWhileLoop {
   mlir::ConversionPatternRewriter *rewriter;
 };
 
+class SCFDoLoop {
+public:
+  SCFDoLoop(mlir::cir::DoWhileOp op, mlir::cir::DoWhileOp::Adaptor adaptor,
+            mlir::ConversionPatternRewriter *rewriter)
+      : DoOp(op), adaptor(adaptor), rewriter(rewriter) {}
+  void transferToSCFWhileOp();
+
+private:
+  mlir::cir::DoWhileOp DoOp;
+  mlir::cir::DoWhileOp::Adaptor adaptor;
+  mlir::ConversionPatternRewriter *rewriter;
+};
+
 static int64_t getConstant(mlir::cir::ConstantOp op) {
   auto attr = op->getAttrs().front().getValue();
   const auto IntAttr = attr.dyn_cast<mlir::cir::IntAttr>();
@@ -261,6 +274,40 @@ void SCFWhileLoop::transferToSCFWhileOp() {
   rewriter->eraseBlock(&scfWhileOp.getAfter().back());
 }
 
+void SCFDoLoop::transferToSCFWhileOp() {
+  // only support a simple do-while
+  // FIXME: can not support nested do-while
+
+  auto scfWhileOp = rewriter->create<mlir::scf::WhileOp>(
+      DoOp.getLoc(), DoOp->getResultTypes(), adaptor.getOperands());
+
+  rewriter->createBlock(&scfWhileOp.getBefore());
+  rewriter->createBlock(&scfWhileOp.getAfter());
+
+  rewriter->cloneRegionBefore(DoOp.getBody(), &scfWhileOp.getBefore().back());
+  rewriter->eraseBlock(&scfWhileOp.getBefore().back());
+
+  rewriter->cloneRegionBefore(DoOp.getCond(), &scfWhileOp.getAfter().back());
+  rewriter->eraseBlock(&scfWhileOp.getAfter().back());
+
+  rewriter->inlineBlockBefore(&scfWhileOp.getAfter().back(),
+                              &scfWhileOp.getBefore().back(),
+                              scfWhileOp.getBefore().back().end());
+
+  rewriter->createBlock(&scfWhileOp.getAfter());
+
+  auto &beforeFrontBlock = scfWhileOp.getBefore().front();
+  for (auto it = beforeFrontBlock.begin(); it != beforeFrontBlock.end(); ++it) {
+    if (auto yieldOp = llvm::dyn_cast<mlir::cir::YieldOp>(&*it)) {
+      rewriter->eraseOp(yieldOp);
+      break;
+    }
+  }
+
+  rewriter->setInsertionPointToEnd(&scfWhileOp.getAfter().front());
+  rewriter->create<mlir::scf::YieldOp>(DoOp.getLoc());
+}
+
 class CIRForOpLowering : public mlir::OpConversionPattern<mlir::cir::ForOp> {
 public:
   using OpConversionPattern<mlir::cir::ForOp>::OpConversionPattern;
@@ -291,6 +338,20 @@ class CIRWhileOpLowering
   }
 };
 
+class CIRDoOpLowering : public mlir::OpConversionPattern<mlir::cir::DoWhileOp> {
+public:
+  using OpConversionPattern<mlir::cir::DoWhileOp>::OpConversionPattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(mlir::cir::DoWhileOp op, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    SCFDoLoop loop(op, adaptor, &rewriter);
+    loop.transferToSCFWhileOp();
+    rewriter.eraseOp(op);
+    return mlir::success();
+  }
+};
+
 class CIRConditionOpLowering
     : public mlir::OpConversionPattern<mlir::cir::ConditionOp> {
 public:
@@ -314,8 +375,8 @@ class CIRConditionOpLowering
 
 void populateCIRLoopToSCFConversionPatterns(mlir::RewritePatternSet &patterns,
                                             mlir::TypeConverter &converter) {
-  patterns.add<CIRForOpLowering, CIRWhileOpLowering, CIRConditionOpLowering>(
-      converter, patterns.getContext());
+  patterns.add<CIRForOpLowering, CIRWhileOpLowering, CIRConditionOpLowering,
+               CIRDoOpLowering>(converter, patterns.getContext());
 }
 
-} // namespace cir
+} // namespace cir

clang/test/CIR/Lowering/ThroughMLIR/doWhile.c

@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -fno-clangir-direct-lowering -emit-mlir %s -o %t.mlir
+// RUN: FileCheck --input-file=%t.mlir %s
+
+int sum() {
+  int s = 0;
+  int i = 0;
+  do {
+    s += i;
+    ++i;
+  } while (i <= 10);
+  return s;
+}
+
+// CHECK: func.func @sum() -> i32 {
+// CHECK: %[[ALLOC:.+]] = memref.alloca() {alignment = 4 : i64} : memref<i32>
+// CHECK: %[[ALLOC0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<i32>
+// CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref<i32>
+// CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32
+// CHECK: memref.store %[[C0_I32]], %[[ALLOC0]][] : memref<i32>
+// CHECK: %[[C0_I32_2:.+]] = arith.constant 0 : i32
+// CHECK: memref.store %[[C0_I32_2]], %[[ALLOC1]][] : memref<i32>
+// CHECK: memref.alloca_scope {
+// CHECK:   scf.while : () -> () {
+// CHECK:     %[[VAR1:.+]] = memref.load %[[ALLOC1]][] : memref<i32>
+// CHECK:     %[[VAR2:.+]] = memref.load %[[ALLOC0]][] : memref<i32>
+// CHECK:     %[[ADD:.+]] = arith.addi %[[VAR2]], %[[VAR1]] : i32
+// CHECK:     memref.store %[[ADD]], %[[ALLOC0]][] : memref<i32>
+// CHECK:     %[[VAR3:.+]] = memref.load %[[ALLOC1]][] : memref<i32>
+// CHECK:     %[[C1_I32:.+]] = arith.constant 1 : i32
+// CHECK:     %[[ADD1:.+]] = arith.addi %[[VAR3]], %[[C1_I32]] : i32
+// CHECK:     memref.store %[[ADD1]], %[[ALLOC1]][] : memref<i32>
+// CHECK:     %[[VAR4:.+]] = memref.load %[[ALLOC1]][] : memref<i32>
+// CHECK:     %[[C10_I32:.+]] = arith.constant 10 : i32
+// CHECK:     %[[CMP:.+]] = arith.cmpi ule, %[[VAR4]], %[[C10_I32]] : i32
+// CHECK:     %[[EXT:.+]] = arith.extui %[[CMP]] : i1 to i32
+// CHECK:     %[[C0_I32_3:.+]] = arith.constant 0 : i32
+// CHECK:     %[[NE:.+]] = arith.cmpi ne, %[[EXT]], %[[C0_I32_3]] : i32
+// CHECK:     %[[EXT1:.+]] = arith.extui %[[NE]] : i1 to i8
+// CHECK:     %[[TRUNC:.+]] = arith.trunci %[[EXT1]] : i8 to i1
+// CHECK:     scf.condition(%[[TRUNC]])
+// CHECK:   } do {
+// CHECK:     scf.yield
+// CHECK:   }
+// CHECK: }
+// CHECK: %[[LOAD:.+]] = memref.load %[[ALLOC0]][] : memref<i32>
+// CHECK: memref.store %[[LOAD]], %[[ALLOC]][] : memref<i32>
+// CHECK: %[[RET:.+]] = memref.load %[[ALLOC]][] : memref<i32>
+// CHECK: return %[[RET]] : i32