change isneighbour to compute async topo

Mapper/instruction.py

@@ -109,7 +109,7 @@ def printAssembly(self):
         output = ""
         BRs = ["BEQ","BNE","BLT","BGE","BLE","BGT"]
         if self.getOpcodeName() == "MV":
-            output += "SADD " + self.getOutputOperandAssignedRegister() + ", "
+            output += "MV " + self.getOutputOperandAssignedRegister() + ", "
             if self.opA == ZERO or self.opA == CONST:
                 output += self.getRigthOperandAssignedRegister() + ", "
             else:

Mapper/mapper.py

@@ -521,6 +521,27 @@ def addConstraint3(self, II, c_n_it_p_literal, cycle_pe_literals):
         end = time.time()
         print("Time: " + str(end - start))
         return all_dep_encoded
+
+    def printconstraints(self, filepath, seed = 0):
+        import random
+        random.seed(seed)
+
+        # Retrieve constraints
+        constraints = self.s.assertions()
+        # Shuffle constraints
+        constraints_list = list(constraints)
+        random.shuffle(constraints_list)
+
+        # Remove all constraints from the solver
+        self.s.reset()
+        # Add shuffled constraints back to the solver
+        for constraint in constraints_list:
+            self.s.add(constraint)
+
+        # Open a file in write mode
+        with open(filepath, 'w') as file:
+            for constraint in self.s.assertions():
+                file.write(str(constraint) + '\n\n')
 
     #Find mapping of the DFG starting from the MII
     #TODO: (Low priority) add upperbound for II
@@ -641,6 +662,9 @@ def findMapping(self):
 
             start = time.time()
 
+            # try to print all constraints
+            self.printconstraints('./constraints.txt')
+
             if self.s.check() == sat:
                 #model_number = 0
                 #while self.s.check() == sat:

benchmarks/BitCount/BitCount.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <math.h>
+
+
+int BitCount(long x)
+{
+        int n = 0;
+/*
+** The loop will execute once for each bit of x set, this is in average
+** twice as fast as the shift/test method.
+*/
+        if (x == 0){
+            return 0;
+        }
+
+        do{
+          n++;
+        }while (0 != (x = x&(x-1)));
+
+        return(n);
+}
+
+
+int main(){
+
+  int a = 123123;
+
+  int res = BitCount(a);
+
+  printf("%d", res);
+  return 0;
+
+}

benchmarks/BitCount/IR/cf.mlir

@@ -0,0 +1,35 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  func.func @BitCount(%arg0: i64) -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+    %c-1_i64 = arith.constant -1 : i64
+    %c1_i32 = arith.constant 1 : i32
+    %c0_i64 = arith.constant 0 : i64
+    %c0_i32 = arith.constant 0 : i32
+    %0 = llvm.mlir.undef : i32
+    %1 = arith.cmpi eq, %arg0, %c0_i64 : i64
+    %2 = arith.cmpi ne, %arg0, %c0_i64 : i64
+    cf.cond_br %2, ^bb1, ^bb5
+  ^bb1:  // pred: ^bb0
+    cf.br ^bb2(%c0_i32, %arg0 : i32, i64)
+  ^bb2(%3: i32, %4: i64):  // 2 preds: ^bb1, ^bb3
+    %5 = arith.addi %3, %c1_i32 : i32
+    %6 = arith.addi %4, %c-1_i64 : i64
+    %7 = arith.andi %4, %6 : i64
+    %8 = arith.cmpi ne, %7, %c0_i64 : i64
+    cf.cond_br %8, ^bb3(%5, %3, %4 : i32, i32, i64), ^bb4
+  ^bb3(%9: i32, %10: i32, %11: i64):  // pred: ^bb2
+    %12 = arith.addi %11, %c-1_i64 : i64
+    %13 = arith.andi %11, %12 : i64
+    %14 = arith.addi %10, %c1_i32 : i32
+    cf.br ^bb2(%14, %13 : i32, i64)
+  ^bb4:  // pred: ^bb2
+    cf.br ^bb6(%5 : i32)
+  ^bb5:  // pred: ^bb0
+    %15 = arith.select %1, %c0_i32, %0 : i32
+    cf.br ^bb6(%15 : i32)
+  ^bb6(%16: i32):  // 2 preds: ^bb4, ^bb5
+    cf.br ^bb7
+  ^bb7:  // pred: ^bb6
+    return %16 : i32
+  }
+}
+

benchmarks/BitCount/IR/llvm.mlir

@@ -0,0 +1,29 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  llvm.func @BitCount(%arg0: i64) -> i32 {
+    %0 = llvm.mlir.constant(-1 : i64) : i64
+    %1 = llvm.mlir.constant(1 : i32) : i32
+    %2 = llvm.mlir.constant(0 : i64) : i64
+    %3 = llvm.mlir.constant(0 : i32) : i32
+    %4 = llvm.mlir.undef : i32
+    %5 = llvm.icmp "eq" %arg0, %2 : i64
+    %6 = llvm.icmp "ne" %arg0, %2 : i64
+    llvm.cond_br %6, ^bb1(%3, %arg0 : i32, i64), ^bb3
+  ^bb1(%7: i32, %8: i64):  // 2 preds: ^bb0, ^bb2
+    %9 = llvm.add %7, %1  : i32
+    %10 = llvm.add %8, %0  : i64
+    %11 = llvm.and %8, %10  : i64
+    %12 = llvm.icmp "ne" %11, %2 : i64
+    llvm.cond_br %12, ^bb2(%7, %8 : i32, i64), ^bb4(%9 : i32)
+  ^bb2(%13: i32, %14: i64):  // pred: ^bb1
+    %15 = llvm.add %14, %0  : i64
+    %16 = llvm.and %14, %15  : i64
+    %17 = llvm.add %13, %1  : i32
+    llvm.br ^bb1(%17, %16 : i32, i64)
+  ^bb3:  // pred: ^bb0
+    %18 = llvm.select %5, %3, %4 : i1, i32
+    llvm.br ^bb4(%18 : i32)
+  ^bb4(%19: i32):  // 2 preds: ^bb1, ^bb3
+    llvm.return %19 : i32
+  }
+}
+

benchmarks/BitCount/IR/scf.mlir

@@ -0,0 +1,31 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  func.func @BitCount(%arg0: i64) -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+    %c-1_i64 = arith.constant -1 : i64
+    %c1_i32 = arith.constant 1 : i32
+    %c0_i64 = arith.constant 0 : i64
+    %c0_i32 = arith.constant 0 : i32
+    %0 = llvm.mlir.undef : i32
+    %1 = arith.cmpi eq, %arg0, %c0_i64 : i64
+    %2 = arith.cmpi ne, %arg0, %c0_i64 : i64
+    %3 = scf.if %2 -> (i32) {
+      %4:3 = scf.while (%arg1 = %c0_i32, %arg2 = %arg0) : (i32, i64) -> (i32, i32, i64) {
+        %5 = arith.addi %arg1, %c1_i32 : i32
+        %6 = arith.addi %arg2, %c-1_i64 : i64
+        %7 = arith.andi %arg2, %6 : i64
+        %8 = arith.cmpi ne, %7, %c0_i64 : i64
+        scf.condition(%8) %5, %arg1, %arg2 : i32, i32, i64
+      } do {
+      ^bb0(%arg1: i32, %arg2: i32, %arg3: i64):
+        %5 = arith.addi %arg3, %c-1_i64 : i64
+        %6 = arith.andi %arg3, %5 : i64
+        %7 = arith.addi %arg2, %c1_i32 : i32
+        scf.yield %7, %6 : i32, i64
+      }
+      scf.yield %4#0 : i32
+    } else {
+      %4 = arith.select %1, %c0_i32, %0 : i32
+      scf.yield %4 : i32
+    }
+    return %3 : i32
+  }
+}

benchmarks/GSM/GSM.c

@@ -0,0 +1,28 @@
+#include<stdio.h>
+
+# define GSM_ABS(a) ((a) < 0 ? ((a) == MIN_WORD ? MAX_WORD : -(a)) : (a))
+#define MIN_WORD    ((-32767)-1)
+#define MAX_WORD    ( 32767)
+
+int GSM(int *d){
+
+    int dmax = 0;
+    int temp = 0;
+
+    #pragma CGRA
+    for (int k = 0; k <= 39; k++) {
+        temp = d[k];
+        temp = GSM_ABS( temp );
+        if (temp > dmax) dmax = temp;
+    }
+
+    return dmax;
+}
+
+int main(){
+
+	int d[50];
+	GSM(d);
+
+
+}

benchmarks/GSM/IR/cf.mlir

@@ -0,0 +1,42 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  func.func @GSM(%arg0: memref<?xi32>) -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+    %c40 = arith.constant 40 : index
+    %c0 = arith.constant 0 : index
+    %c1 = arith.constant 1 : index
+    %c32767_i32 = arith.constant 32767 : i32
+    %c-32768_i32 = arith.constant -32768 : i32
+    %c0_i32 = arith.constant 0 : i32
+    cf.br ^bb1(%c0, %c0_i32 : index, i32)
+  ^bb1(%0: index, %1: i32):  // 2 preds: ^bb0, ^bb10
+    %2 = arith.cmpi slt, %0, %c40 : index
+    cf.cond_br %2, ^bb2, ^bb11
+  ^bb2:  // pred: ^bb1
+    %3 = memref.load %arg0[%0] : memref<?xi32>
+    %4 = arith.cmpi slt, %3, %c0_i32 : i32
+    %5 = arith.cmpi eq, %3, %c-32768_i32 : i32
+    cf.cond_br %4, ^bb3, ^bb8
+  ^bb3:  // pred: ^bb2
+    cf.cond_br %5, ^bb4, ^bb5
+  ^bb4:  // pred: ^bb3
+    cf.br ^bb6(%c32767_i32 : i32)
+  ^bb5:  // pred: ^bb3
+    %6 = arith.subi %c0_i32, %3 : i32
+    cf.br ^bb6(%6 : i32)
+  ^bb6(%7: i32):  // 2 preds: ^bb4, ^bb5
+    cf.br ^bb7
+  ^bb7:  // pred: ^bb6
+    cf.br ^bb9(%7 : i32)
+  ^bb8:  // pred: ^bb2
+    cf.br ^bb9(%3 : i32)
+  ^bb9(%8: i32):  // 2 preds: ^bb7, ^bb8
+    cf.br ^bb10
+  ^bb10:  // pred: ^bb9
+    %9 = arith.cmpi sgt, %8, %1 : i32
+    %10 = arith.select %9, %8, %1 : i32
+    %11 = arith.addi %0, %c1 : index
+    cf.br ^bb1(%11, %10 : index, i32)
+  ^bb11:  // pred: ^bb1
+    return %1 : i32
+  }
+}
+

benchmarks/GSM/IR/llvm.mlir

@@ -0,0 +1,39 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  llvm.func @GSM(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64, %arg3: i64, %arg4: i64) -> i32 {
+    %0 = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>
+    %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 
+    %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 
+    %3 = llvm.insertvalue %arg2, %2[2] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 
+    %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 
+    %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 
+    %6 = llvm.mlir.constant(40 : index) : i64
+    %7 = llvm.mlir.constant(0 : index) : i64
+    %8 = llvm.mlir.constant(1 : index) : i64
+    %9 = llvm.mlir.constant(32767 : i32) : i32
+    %10 = llvm.mlir.constant(-32768 : i32) : i32
+    %11 = llvm.mlir.constant(0 : i32) : i32
+    llvm.br ^bb1(%7, %11 : i64, i32)
+  ^bb1(%12: i64, %13: i32):  // 2 preds: ^bb0, ^bb5
+    %14 = llvm.icmp "slt" %12, %6 : i64
+    llvm.cond_br %14, ^bb2, ^bb6
+  ^bb2:  // pred: ^bb1
+    %15 = llvm.getelementptr %arg1[%12] : (!llvm.ptr, i64) -> !llvm.ptr, i32
+    %16 = llvm.load %15 : !llvm.ptr -> i32
+    %17 = llvm.icmp "slt" %16, %11 : i32
+    %18 = llvm.icmp "eq" %16, %10 : i32
+    llvm.cond_br %17, ^bb3, ^bb5(%16 : i32)
+  ^bb3:  // pred: ^bb2
+    llvm.cond_br %18, ^bb5(%9 : i32), ^bb4
+  ^bb4:  // pred: ^bb3
+    %19 = llvm.sub %11, %16  : i32
+    llvm.br ^bb5(%19 : i32)
+  ^bb5(%20: i32):  // 3 preds: ^bb2, ^bb3, ^bb4
+    %21 = llvm.icmp "sgt" %20, %13 : i32
+    %22 = llvm.select %21, %20, %13 : i1, i32
+    %23 = llvm.add %12, %8  : i64
+    llvm.br ^bb1(%23, %22 : i64, i32)
+  ^bb6:  // pred: ^bb1
+    llvm.return %13 : i32
+  }
+}
+

benchmarks/GSM/IR/scf.mlir

@@ -0,0 +1,30 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>, #dlti.dl_entry<"dlti.endianness", "little">>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  func.func @GSM(%arg0: memref<?xi32>) -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+    %c40 = arith.constant 40 : index
+    %c0 = arith.constant 0 : index
+    %c1 = arith.constant 1 : index
+    %c32767_i32 = arith.constant 32767 : i32
+    %c-32768_i32 = arith.constant -32768 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %0 = scf.for %arg1 = %c0 to %c40 step %c1 iter_args(%arg2 = %c0_i32) -> (i32) {
+      %1 = memref.load %arg0[%arg1] : memref<?xi32>
+      %2 = arith.cmpi slt, %1, %c0_i32 : i32
+      %3 = arith.cmpi eq, %1, %c-32768_i32 : i32
+      %4 = scf.if %2 -> (i32) {
+        %7 = scf.if %3 -> (i32) {
+          scf.yield %c32767_i32 : i32
+        } else {
+          %8 = arith.subi %c0_i32, %1 : i32
+          scf.yield %8 : i32
+        }
+        scf.yield %7 : i32
+      } else {
+        scf.yield %1 : i32
+      }
+      %5 = arith.cmpi sgt, %4, %arg2 : i32
+      %6 = arith.select %5, %4, %arg2 : i32
+      scf.yield %6 : i32
+    }
+    return %0 : i32
+  }
+}

benchmarks/ReverseBits/IR/cf.mlir

@@ -0,0 +1,23 @@
+module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi32>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi32>>, #dlti.dl_entry<f128, dense<128> : vector<2xi32>>, #dlti.dl_entry<f64, dense<64> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi32>>, #dlti.dl_entry<i32, dense<32> : vector<2xi32>>, #dlti.dl_entry<f16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i16, dense<16> : vector<2xi32>>, #dlti.dl_entry<i1, dense<8> : vector<2xi32>>, #dlti.dl_entry<i8, dense<8> : vector<2xi32>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi32>>, #dlti.dl_entry<f80, dense<128> : vector<2xi32>>, #dlti.dl_entry<i64, dense<64> : vector<2xi32>>, #dlti.dl_entry<"dlti.endianness", "little">, #dlti.dl_entry<"dlti.stack_alignment", 128 : i32>>, llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", llvm.target_triple = "x86_64-unknown-linux-gnu", "polygeist.target-cpu" = "x86-64", "polygeist.target-features" = "+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87", "polygeist.tune-cpu" = "generic"} {
+  func.func @ReverseBits(%arg0: i32, %arg1: i32) -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+    %c0 = arith.constant {"time" = 0, "units" = 0} 0 : index 
+    %c1 = arith.constant 1 : index
+    %c1_i32 = arith.constant 1 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %0 = arith.index_cast %arg1 : i32 to index
+    cf.br ^bb1(%c0, %c0_i32, %arg0 : index, i32, i32)
+  ^bb1(%1: index, %2: i32, %3: i32):  // 2 preds: ^bb0, ^bb2
+    %4 = arith.cmpi slt, %1, %0 : index
+    cf.cond_br %4, ^bb2, ^bb3
+  ^bb2:  // pred: ^bb1
+    %5 = arith.shli %2, %c1_i32 {"time"= 0, "units"=3} : i32
+    %6 = arith.andi %3, %c1_i32 : i32
+    %7 = arith.ori %5, %6 : i32
+    %8 = arith.shrui %3, %c1_i32 : i32
+    %9 = arith.addi %1, %c1 : index
+    cf.br ^bb1(%9, %7, %8 : index, i32, i32)
+  ^bb3:  // pred: ^bb1
+    return %2 : i32
+  }
+}
+