merge-cleanups.cir

// RUN: cir-opt %s -cir-merge-cleanups -o %t.out.cir
// RUN: FileCheck --input-file=%t.out.cir %s

#false = #cir.bool<false> : !cir.bool
#true = #cir.bool<true> : !cir.bool
!s32i = !cir.int<s, 32>
module  {
  cir.func @sw1(%arg0: !s32i, %arg1: !s32i) {
    %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
    %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init] {alignment = 4 : i64}
    cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
    cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
    cir.scope {
      %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
      %3 = cir.const #cir.int<1> : !s32i
      cir.store %3, %2 : !s32i, !cir.ptr<!s32i>
      %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
      cir.switch (%4 : !s32i) [
      case (equal, 0 : !s32i)  {
        %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
        %6 = cir.const #cir.int<1> : !s32i
        %7 = cir.binop(add, %5, %6) : !s32i
        cir.store %7, %2 : !s32i, !cir.ptr<!s32i>
        cir.br ^bb1
      ^bb1:  // pred: ^bb0
        cir.return
      },
      case (equal, 1 : !s32i)  {
        cir.scope {
          cir.scope {
            %5 = cir.load %1 : !cir.ptr<!s32i>, !s32i
            %6 = cir.const #cir.int<3> : !s32i
            %7 = cir.cmp(eq, %5, %6) : !s32i, !cir.bool
            cir.if %7 {
              cir.br ^bb1
            ^bb1:  // pred: ^bb0
              cir.return
            }
          }
          cir.break
        }
        cir.yield
      },
      case (equal, 2 : !s32i)  {
        cir.scope {
          %5 = cir.alloca !s32i, !cir.ptr<!s32i>, ["yolo", init] {alignment = 4 : i64}
          %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
          %7 = cir.const #cir.int<1> : !s32i
          %8 = cir.binop(add, %6, %7) : !s32i
          cir.store %8, %2 : !s32i, !cir.ptr<!s32i>
          %9 = cir.const #cir.int<100> : !s32i
          cir.store %9, %5 : !s32i, !cir.ptr<!s32i>
          cir.br ^bb1
        ^bb1:  // pred: ^bb0
          cir.return
        }
        cir.yield
      }
      ]
    }
    cir.return
  }

// CHECK: cir.switch (%4 : !s32i) [
// CHECK-NEXT:   case (equal, 0)  {
// CHECK-NEXT:     %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT:     %6 = cir.const #cir.int<1> : !s32i
// CHECK-NEXT:     %7 = cir.binop(add, %5, %6) : !s32i
// CHECK-NEXT:     cir.store %7, %2 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT:     cir.return
// CHECK-NEXT:   },
// CHECK-NEXT:   case (equal, 1)  {
// CHECK-NEXT:     cir.scope {
// CHECK-NEXT:       cir.scope {
// CHECK-NEXT:         %5 = cir.load %1 : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT:         %6 = cir.const #cir.int<3> : !s32i
// CHECK-NEXT:         %7 = cir.cmp(eq, %5, %6) : !s32i, !cir.bool
// CHECK-NEXT:         cir.if %7 {
// CHECK-NEXT:           cir.return
// CHECK-NEXT:         }
// CHECK-NEXT:       }
// CHECK-NEXT:       cir.break
// CHECK-NEXT:     }
// CHECK-NEXT:     cir.yield
// CHECK-NEXT:   },
// CHECK-NEXT:   case (equal, 2)  {
// CHECK-NEXT:     cir.scope {
// CHECK-NEXT:       %5 = cir.alloca !s32i, !cir.ptr<!s32i>, ["yolo", init] {alignment = 4 : i64}
// CHECK-NEXT:       %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT:       %7 = cir.const #cir.int<1> : !s32i
// CHECK-NEXT:       %8 = cir.binop(add, %6, %7) : !s32i
// CHECK-NEXT:       cir.store %8, %2 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT:       %9 = cir.const #cir.int<100> : !s32i
// CHECK-NEXT:       cir.store %9, %5 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT:       cir.return
// CHECK-NEXT:     }
// CHECK-NEXT:     cir.yield
// CHECK-NEXT:   }
// CHECK-NEXT: ]

  // Should remove empty scopes.
  cir.func @removeEmptyScope() {
    cir.scope {
    }
    cir.return
  }
  //      CHECK: cir.func @removeEmptyScope
  // CHECK-NEXT: cir.return

  // Should remove empty switch-case statements.
  cir.func @removeEmptySwitch(%arg0: !s32i) {
  //      CHECK: cir.func @removeEmptySwitch
    cir.switch (%arg0 : !s32i) [
    ]
    // CHECK-NOT: cir.switch
    cir.return
    // CHECK: cir.return
  }

  // Should remove redundant bitcasts.
  // CHECK-LABEL: @ptrbitcastfold
  //       CHECK:  %[[ARG0:.+]]: !cir.ptr<!s32i>
  //       CHECK:  cir.return %[[ARG0]] : !cir.ptr<!s32i>
  cir.func @ptrbitcastfold(%arg0: !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {
    %0 = cir.cast(bitcast, %arg0: !cir.ptr<!s32i>), !cir.ptr<!s32i>
    cir.return %0 : !cir.ptr<!s32i>
  }

}