[CIR][Lowering] Lower structured do-while loops

Conditionally set the loop entry point depending on whether the loop is
of the `do-while` kind or not.

ghstack-source-id: 2603086
Pull Request resolved: #146

Author: sitio-couto

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -135,7 +135,8 @@ class CIRLoopOpLowering : public mlir::OpConversionPattern<mlir::cir::LoopOp> {
 
   mlir::LogicalResult
   rewriteWhileLoop(mlir::cir::LoopOp loopOp, OpAdaptor adaptor,
-                   mlir::ConversionPatternRewriter &rewriter) const {
+                   mlir::ConversionPatternRewriter &rewriter,
+                   mlir::cir::LoopOpKind kind) const {
     auto *currentBlock = rewriter.getInsertionBlock();
     auto *continueBlock =
         rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());
@@ -158,9 +159,10 @@ class CIRLoopOpLowering : public mlir::OpConversionPattern<mlir::cir::LoopOp> {
     rewriter.inlineRegionBefore(condRegion, continueBlock);
     rewriter.inlineRegionBefore(bodyRegion, continueBlock);
 
-    // Set loop entry point to condition block.
+    // Set loop entry point to condition or to body in do-while cases.
     rewriter.setInsertionPointToEnd(currentBlock);
-    rewriter.create<mlir::cir::BrOp>(loopOp.getLoc(), &condFrontBlock);
+    auto &entry = (kind != LoopKind::DoWhile ? condFrontBlock : bodyFrontBlock);
+    rewriter.create<mlir::cir::BrOp>(loopOp.getLoc(), &entry);
 
     // Set loop exit point to continue block.
     rewriter.setInsertionPoint(yieldToCont);
@@ -186,9 +188,8 @@ class CIRLoopOpLowering : public mlir::OpConversionPattern<mlir::cir::LoopOp> {
     case LoopKind::For:
       break;
     case LoopKind::While:
-      return rewriteWhileLoop(loopOp, adaptor, rewriter);
     case LoopKind::DoWhile:
-      llvm_unreachable("NYI");
+      return rewriteWhileLoop(loopOp, adaptor, rewriter, loopOp.getKind());
     }
 
     auto loc = loopOp.getLoc();

clang/test/CIR/Lowering/loop.cir

@@ -154,4 +154,64 @@ module {
   // MLIR-NEXT:  ^bb6:  // pred: ^bb4
   // MLIR-NEXT:    llvm.br ^bb7
 
+  // Test do-while cir.loop operation lowering.
+  cir.func @testDoWhile(%arg0: !s32i) {
+    %0 = cir.alloca !s32i, cir.ptr <!s32i>, ["i", init] {alignment = 4 : i64}
+    cir.store %arg0, %0 : !s32i, cir.ptr <!s32i>
+    cir.scope {
+      cir.loop dowhile(cond : {
+        %1 = cir.load %0 : cir.ptr <!s32i>, !s32i
+        %2 = cir.const(#cir.int<10> : !s32i) : !s32i
+        %3 = cir.cmp(lt, %1, %2) : !s32i, !s32i
+        %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+        cir.brcond %4 ^bb1, ^bb2
+      ^bb1:  // pred: ^bb0
+        cir.yield continue
+      ^bb2:  // pred: ^bb0
+        cir.yield
+      }, step : {
+        cir.yield
+      }) {
+        %1 = cir.load %0 : cir.ptr <!s32i>, !s32i
+        %2 = cir.unary(inc, %1) : !s32i, !s32i
+        cir.store %2, %0 : !s32i, cir.ptr <!s32i>
+        cir.yield
+      }
+    }
+    cir.return
+  }
+
+  //      MLIR:  llvm.func @testDoWhile(%arg0: i32) {
+  // MLIR-NEXT:    %0 = llvm.mlir.constant(1 : index) : i64
+  // MLIR-NEXT:    %1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr<i32>
+  // MLIR-NEXT:    llvm.store %arg0, %1 : !llvm.ptr<i32>
+  // MLIR-NEXT:    llvm.br ^bb1
+  // MLIR-NEXT:  ^bb1:
+  // MLIR-NEXT:    llvm.br ^bb5
+  // ============= Condition block =============
+  // MLIR-NEXT:  ^bb2:
+  // MLIR-NEXT:    %2 = llvm.load %1 : !llvm.ptr<i32>
+  // MLIR-NEXT:    %3 = llvm.mlir.constant(10 : i32) : i32
+  // MLIR-NEXT:    %4 = llvm.icmp "slt" %2, %3 : i32
+  // MLIR-NEXT:    %5 = llvm.zext %4 : i1 to i32
+  // MLIR-NEXT:    %6 = llvm.mlir.constant(0 : i32) : i32
+  // MLIR-NEXT:    %7 = llvm.icmp "ne" %5, %6 : i32
+  // MLIR-NEXT:    %8 = llvm.zext %7 : i1 to i8
+  // MLIR-NEXT:    %9 = llvm.trunc %8 : i8 to i1
+  // MLIR-NEXT:    llvm.cond_br %9, ^bb3, ^bb4
+  // MLIR-NEXT:  ^bb3:
+  // MLIR-NEXT:    llvm.br ^bb5
+  // MLIR-NEXT:  ^bb4:
+  // MLIR-NEXT:    llvm.br ^bb6
+  // ============= Body block =============
+  // MLIR-NEXT:  ^bb5:
+  // MLIR-NEXT:    %10 = llvm.load %1 : !llvm.ptr<i32>
+  // MLIR-NEXT:    %11 = llvm.mlir.constant(1 : i32) : i32
+  // MLIR-NEXT:    %12 = llvm.add %10, %11  : i32
+  // MLIR-NEXT:    llvm.store %12, %1 : !llvm.ptr<i32>
+  // MLIR-NEXT:    llvm.br ^bb2
+  // ============= Exit block =============
+  // MLIR-NEXT:  ^bb6:
+  // MLIR-NEXT:    llvm.br ^bb7
+
 }