// RUN: mlir-opt --lift-cf-to-scf -split-input-file %s | FileCheck %s

func.func @simple_if() {
  %cond = "test.test1"() : () -> i1
  cf.cond_br %cond, ^bb1, ^bb2
^bb1:
  "test.test2"() : () -> ()
  cf.br ^bb3
^bb2:
  "test.test3"() : () -> ()
  cf.br ^bb3
^bb3:
  "test.test4"() : () -> ()
  return
}

// CHECK-LABEL: func @simple_if
// CHECK:      %[[COND:.*]] = "test.test1"()
// CHECK-NEXT: scf.if %[[COND]]
// CHECK-NEXT:   "test.test2"()
// CHECK-NEXT: else
// CHECK-NEXT:   "test.test3"()
// CHECK-NEXT: }
// CHECK-NEXT: "test.test4"()
// CHECK-NEXT: return

// -----

func.func @if_with_block_args() -> index {
  %cond = "test.test1"() : () -> i1
  cf.cond_br %cond, ^bb1, ^bb2
^bb1:
  %1 = "test.test2"() : () -> (index)
  cf.br ^bb3(%1: index)
^bb2:
  %2 = "test.test3"() : () -> (index)
  cf.br ^bb3(%2: index)
^bb3(%3: index):
  "test.test4"() : () -> ()
  return %3 : index
}

// CHECK-LABEL: func @if_with_block_args
// CHECK:      %[[COND:.*]] = "test.test1"()
// CHECK-NEXT: %[[RES:.*]] = scf.if %[[COND]]
// CHECK-NEXT:   %[[VAL1:.*]]  = "test.test2"()
// CHECK-NEXT:   scf.yield %[[VAL1]]
// CHECK-NEXT: else
// CHECK-NEXT:   %[[VAL2:.*]]  = "test.test3"()
// CHECK-NEXT:   scf.yield %[[VAL2]]
// CHECK:      "test.test4"()
// CHECK-NEXT: return %[[RES]]

// -----

func.func @empty_else() {
  %cond = "test.test1"() : () -> i1
  cf.cond_br %cond, ^bb1, ^bb3
^bb1:
  "test.test2"() : () -> ()
  cf.br ^bb3
^bb3:
  "test.test4"() : () -> ()
  return
}

// CHECK-LABEL: func @empty_else
// CHECK:      %[[COND:.*]] = "test.test1"()
// CHECK-NEXT: scf.if %[[COND]]
// CHECK-NEXT:   "test.test2"()
// CHECK:      else
// CHECK-NEXT:      }
// CHECK-NEXT: "test.test4"()
// CHECK-NEXT: return

// -----

func.func @while_loop() {
  "test.test1"() : () -> ()
  cf.br ^bb1
^bb1:
  %cond = "test.test2"() : () -> i1
  cf.cond_br %cond, ^bb2, ^bb3
^bb2:
  "test.test3"() : () -> ()
  cf.br ^bb1
^bb3:
  "test.test4"() : () -> ()
  return
}

// CHECK-LABEL: func @while_loop
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-NEXT: "test.test1"()
// CHECK-NEXT: scf.while
// CHECK-NEXT:   %[[COND:.*]] = "test.test2"()
// CHECK-NEXT:   %[[RES:.*]]:2 = scf.if %[[COND]]
// CHECK-NEXT:     "test.test3"()
// CHECK-NEXT:     scf.yield %[[C0]], %[[C1]]
// CHECK-NEXT:   else
// CHECK-NEXT:     scf.yield %[[C1]], %[[C0]]
// CHECK:        %[[COND:.*]] = arith.trunci %[[RES]]#1
// CHECK-NEXT:   scf.condition(%[[COND]])
// CHECK-NEXT: do
// CHECK-NEXT:   scf.yield
// CHECK:      "test.test4"()
// CHECK-NEXT: return

// -----

func.func @while_loop_with_block_args() -> i64{
  %1 = "test.test1"() : () -> index
  cf.br ^bb1(%1: index)
^bb1(%2: index):
  %cond:2 = "test.test2"() : () -> (i1, i64)
  cf.cond_br %cond#0, ^bb2(%cond#1: i64), ^bb3(%cond#1: i64)
^bb2(%3: i64):
  %4 = "test.test3"(%3) : (i64) -> index
  cf.br ^bb1(%4: index)
^bb3(%5: i64):
  "test.test4"() : () -> ()
  return %5 : i64
}

// CHECK-LABEL: func @while_loop_with_block_args
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-DAG: %[[POISON_i64:.*]] = ub.poison : i64
// CHECK-DAG: %[[POISON_index:.*]] = ub.poison : index
// CHECK-NEXT: %[[VAL1:.*]] = "test.test1"()
// CHECK-NEXT: %[[RES:.*]]:2 = scf.while (%[[ARG0:.*]] = %[[VAL1]], %[[ARG1:.*]] = %[[POISON_i64]])
// CHECK-NEXT:   %[[COND:.*]]:2 = "test.test2"()
// CHECK-NEXT:   %[[IF_VALS:.*]]:4 = scf.if %[[COND]]#0
// CHECK-NEXT:     %[[VAL:.*]] = "test.test3"(%[[COND]]#1)
// CHECK-NEXT:     scf.yield %[[VAL]], %[[POISON_i64]], %[[C0]], %[[C1]]
// CHECK-NEXT:   else
// CHECK-NEXT:     scf.yield %[[POISON_index]], %[[COND]]#1, %[[C1]], %[[C0]]
// CHECK:        %[[TRUNC:.*]] = arith.trunci %[[IF_VALS]]#3
// CHECK-NEXT:   scf.condition(%[[TRUNC]]) %[[IF_VALS]]#0, %[[IF_VALS]]#1
// CHECK-NEXT: do
// CHECK-NEXT:   ^{{.+}}(
// CHECK-SAME: [[ARG0:[[:alnum:]]+]]:
// CHECK-SAME: [[ARG1:[[:alnum:]]+]]:
// CHECK-NEXT:   scf.yield %[[ARG0]], %[[ARG1]]
// CHECK:      "test.test4"() : () -> ()
// CHECK-NEXT: return %[[RES]]#1 : i64

// -----

func.func @multi_exit_loop() {
  "test.test1"() : () -> ()
  cf.br ^bb1
^bb1:
  %cond = "test.test2"() : () -> i1
  cf.cond_br %cond, ^bb2, ^bb3
^bb2:
  %cond2 = "test.test3"() : () -> i1
  cf.cond_br %cond2, ^bb3, ^bb1
^bb3:
  "test.test4"() : () -> ()
  return
}

// CHECK-LABEL: func @multi_exit_loop
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-NEXT: "test.test1"()
// CHECK-NEXT: scf.while
// CHECK-NEXT:   %[[COND:.*]] = "test.test2"()
// CHECK-NEXT:   %[[IF_PAIR:.*]]:2 = scf.if %[[COND]]
// CHECK-NEXT:     %[[COND2:.*]] = "test.test3"()
// CHECK-NEXT:     %[[IF_PAIR2:.*]]:2 = scf.if %[[COND2]]
// CHECK-NEXT:       scf.yield %[[C1]], %[[C0]]
// CHECK-NEXT:     else
// CHECK-NEXT:       scf.yield %[[C0]], %[[C1]]
// CHECK:          scf.yield %[[IF_PAIR2]]#0, %[[IF_PAIR2]]#1
// CHECK:        %[[TRUNC:.*]] = arith.trunci %[[IF_PAIR]]#1
// CHECK-NEXT:   scf.condition(%[[TRUNC]])
// CHECK-NEXT: do
// CHECK-NEXT:   scf.yield
// CHECK:      "test.test4"()
// CHECK-NEXT: return

// -----

func.func private @foo(%arg: f32) -> f32
func.func private @bar(%arg: f32)

func.func @switch_with_fallthrough(%flag: i32, %arg1 : f32, %arg2 : f32) {
  cf.switch %flag : i32, [
    default: ^bb1(%arg1 : f32),
    0: ^bb2(%arg2 : f32),
    1: ^bb3
  ]

^bb1(%arg3 : f32):
  %0 = call @foo(%arg3) : (f32) -> f32
  cf.br ^bb2(%0 : f32)

^bb2(%arg4 : f32):
  call @bar(%arg4) : (f32) -> ()
  cf.br ^bb3

^bb3:
  return
}

// CHECK-LABEL: func @switch_with_fallthrough
// CHECK-SAME: %[[ARG0:[[:alnum:]]+]]
// CHECK-SAME: %[[ARG1:[[:alnum:]]+]]
// CHECK-SAME: %[[ARG2:[[:alnum:]]+]]
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-DAG: %[[POISON:.*]] = ub.poison
// CHECK-NEXT: %[[INDEX_CAST:.*]] = arith.index_castui %[[ARG0]]
// CHECK-NEXT: %[[SWITCH_PAIR:.*]]:2 = scf.index_switch %[[INDEX_CAST]]
// CHECK-NEXT: case 0
// CHECK-NEXT:   scf.yield %[[ARG2]], %[[C0]]
// CHECK:      case 1
// CHECK-NEXT:   scf.yield %[[POISON]], %[[C1]]
// CHECK:      default
// CHECK-NEXT:   %[[RES:.*]] = func.call @foo(%[[ARG1]])
// CHECK-NEXT:   scf.yield %[[RES]], %[[C0]]
// CHECK:      %[[INDEX_CAST:.*]] = arith.index_castui %[[SWITCH_PAIR]]#1
// CHECK-NEXT: scf.index_switch %[[INDEX_CAST]]
// CHECK-NEXT: case 0
// CHECK-NEXT:   call @bar(%[[SWITCH_PAIR]]#0)
// CHECK-NEXT:   scf.yield
// CHECK:      default {
// CHECK-NEXT: }
// CHECK-NEXT: return

// -----

func.func private @bar(%arg: f32) -> (i1, f32)

func.func @already_structured_loop(%arg: f32) -> f32 {
  cf.br ^bb0

^bb0:
  %cond, %value = call @bar(%arg) : (f32) -> (i1, f32)
  cf.cond_br %cond, ^bb1, ^bb0

^bb1:
  return %value : f32
}

// CHECK-LABEL: @already_structured_loop
// CHECK-SAME: %[[ARG:.*]]: f32
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-DAG: %[[POISON:.*]] = ub.poison
// CHECK-NEXT: %[[RES:.*]] = scf.while (%[[ARG1:.*]] = %[[POISON]])
// CHECK-NEXT:   %[[CALL_PAIR:.*]]:2 = func.call @bar(%[[ARG]])
// CHECK-NEXT:   %[[IF_PAIR:.*]]:2 = scf.if %[[CALL_PAIR]]#0
// CHECK-NEXT:     scf.yield %[[C1]], %[[C0]]
// CHECK-NEXT:   else
// CHECK-NEXT:     scf.yield %[[C0]], %[[C1]]
// CHECK:        %[[TRUNC:.*]] = arith.trunci %[[IF_PAIR]]#1
// CHECK-NEXT:   scf.condition(%[[TRUNC]]) %[[CALL_PAIR]]#1
// CHECK: return %[[RES]]

// -----

func.func private @bar(%arg: f32) -> (i1, f32)

// This test makes sure that the exit block using an iteration variable works
// correctly.

func.func @exit_loop_iter_use(%arg: f32) -> f32 {
  cf.br ^bb0(%arg : f32)

^bb0(%arg1: f32):
  %cond, %value = call @bar(%arg1) : (f32) -> (i1, f32)
  cf.cond_br %cond, ^bb1, ^bb0(%value : f32)

^bb1:
  return %arg1 : f32
}

// CHECK-LABEL: @exit_loop_iter_use
// CHECK-SAME: %[[ARG:.*]]:
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-DAG: %[[POISON:.*]] = ub.poison
// CHECK-NEXT: %[[RES:.*]]:2 = scf.while
// CHECK-SAME:   %[[ARG1:.*]] = %[[ARG]]
// CHECK-SAME:   %[[ARG2:.*]] = %[[POISON]]
// CHECK-NEXT:   %[[CALL_PAIR:.*]]:2 = func.call @bar(%[[ARG1]])
// CHECK-NEXT:   %[[IF_RES:.*]]:3 = scf.if %[[CALL_PAIR]]#0
// CHECK-NEXT:     scf.yield %[[POISON]], %[[C1]], %[[C0]]
// CHECK-NEXT:   else
// CHECK-NEXT:     scf.yield %[[CALL_PAIR]]#1, %[[C0]], %[[C1]]
// CHECK:        %[[TRUNC:.*]] = arith.trunci %[[IF_RES]]#2
// CHECK-NEXT:   scf.condition(%[[TRUNC]]) %[[IF_RES]]#0, %[[ARG1]]
// CHECK: return %[[RES]]#1

// -----

func.func private @bar(%arg: f32) -> f32

func.func @infinite_loop(%arg: f32) -> f32 {
  cf.br ^bb1(%arg: f32)

^bb1(%arg1: f32):
  %0 = call @bar(%arg1) : (f32) -> f32
  cf.br ^bb1(%0 : f32)
}

// CHECK-LABEL: @infinite_loop
// CHECK-SAME: %[[ARG:.*]]:
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-NEXT: scf.while
// CHECK-SAME:   %[[ARG1:.*]] = %[[ARG]]
// CHECK-NEXT:   %[[CALL:.*]] = func.call @bar(%[[ARG1]])
// CHECK-NEXT:   %[[TRUNC:.*]] = arith.trunci %[[C1]]
// CHECK-NEXT:   scf.condition(%[[TRUNC]]) %[[CALL]]
// CHECK: %[[POISON:.*]] = ub.poison
// CHECK: return %[[POISON]]

// -----

func.func @multi_return() -> i32 {
  %cond = "test.test1"() : () -> i1
  cf.cond_br %cond, ^bb1, ^bb3
^bb1:
  %0 = "test.test2"() : () -> i32
  return %0 : i32
^bb3:
  %1 = "test.test4"() : () -> i32
  return %1 : i32
}

// CHECK-LABEL: func @multi_return
// CHECK:      %[[COND:.*]] = "test.test1"()
// CHECK-NEXT: %[[RES:.*]] = scf.if %[[COND]]
// CHECK-NEXT:   %[[VAL2:.*]] = "test.test2"()
// CHECK:        scf.yield %[[VAL2]]
// CHECK-NEXT: else
// CHECK-NEXT:   %[[VAL4:.*]] = "test.test4"()
// CHECK:        scf.yield %[[VAL4]]
// CHECK:      return %[[RES]]

// -----

func.func private @bar(%arg: f32) -> f32

func.func @conditional_infinite_loop(%arg: f32, %cond: i1) -> f32 {
  cf.cond_br %cond, ^bb1(%arg: f32), ^bb2

^bb1(%arg1: f32):
  %0 = call @bar(%arg1) : (f32) -> f32
  cf.br ^bb1(%0 : f32)

^bb2:
  return %arg : f32
}

// CHECK-LABEL: @conditional_infinite_loop
// CHECK-SAME: %[[ARG0:[[:alnum:]]+]]:
// CHECK-SAME: %[[ARG1:[[:alnum:]]+]]:
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-NEXT: %[[RES:.*]] = scf.if %[[ARG1]]
// CHECK-NEXT:   scf.while
// CHECK-SAME:     %[[ARG2:.*]] = %[[ARG0]]
// CHECK-NEXT:     %[[CALL:.*]] = func.call @bar(%[[ARG2]])
// CHECK-NEXT:     %[[TRUNC:.*]] = arith.trunci %[[C1]]
// CHECK-NEXT:     scf.condition(%[[TRUNC]]) %[[CALL]]
// CHECK:      else
// CHECK:        scf.yield %[[ARG0]]
// CHECK:      return %[[RES]]

// -----

// Different return-like terminators lead one control flow op remaining in the top level region.
// Each of the blocks the control flow op leads to are transformed into regions nevertheless.

func.func private @bar(%arg: i32)

func.func @mixing_return_like(%cond: i1, %cond2: i1, %cond3: i1) {
  %0 = arith.constant 0 : i32
  %1 = arith.constant 1 : i32
  cf.cond_br %cond, ^bb1, ^bb3

^bb1:
  cf.cond_br %cond2, ^bb2(%0 : i32), ^bb2(%1 : i32)
^bb2(%arg: i32):
  call @bar(%arg) : (i32) -> ()
  "test.returnLike"() : () -> ()

^bb3:
  cf.cond_br %cond3, ^bb4(%1 : i32), ^bb4(%0 : i32)
^bb4(%arg2: i32):
  call @bar(%arg2) : (i32) -> ()
  return
}

// CHECK-LABEL: @mixing_return_like
// CHECK-SAME: %[[COND1:[[:alnum:]]+]]:
// CHECK-SAME: %[[COND2:[[:alnum:]]+]]:
// CHECK-SAME: %[[COND3:[[:alnum:]]+]]:
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK: cf.cond_br %[[COND1]], ^[[BB1:.*]], ^[[BB2:[[:alnum:]]+]]

// CHECK: ^[[BB1]]:
// CHECK: scf.if
// CHECK-NOT: cf.{{(switch|(cond_)?br)}}
// CHECK: call @bar
// CHECK: "test.returnLike"

// CHECK: ^[[BB2]]:
// CHECK: scf.if
// CHECK-NOT: cf.{{(switch|(cond_)?br)}}
// CHECK: call @bar
// CHECK: return

// -----

// cf.switch here only has some successors with different return-like ops.
// This test makes sure that if there are at least two successors branching to
// the same region, that this region gets properly turned to structured control
// flow.

func.func @some_successors_with_different_return(%flag: i32) -> i32 {
  %0 = arith.constant 5 : i32
  %1 = arith.constant 6 : i32
  cf.switch %flag : i32, [
    default: ^bb1,
    0: ^bb3(%0 : i32),
    1: ^bb3(%1 : i32)
  ]

^bb1:
  "test.returnLike"() : () -> ()

^bb3(%arg: i32):
  cf.br ^bb3(%arg : i32)
}

// CHECK-LABEL: @some_successors_with_different_return
// CHECK-SAME: %[[FLAG:[[:alnum:]]+]]:
// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32
// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32
// CHECK-DAG: %[[POISON:.*]] = ub.poison
// CHECK-DAG: %[[C5:.*]] = arith.constant 5 : i32
// CHECK-DAG: %[[C6:.*]] = arith.constant 6 : i32
// CHECK:      %[[INDEX_CAST:.*]] = arith.index_castui %[[FLAG]]
// CHECK-NEXT: %[[INDEX_SWITCH:.*]]:2 = scf.index_switch %[[INDEX_CAST]]
// CHECK:      case 0
// CHECK-NEXT:   scf.yield %[[C5]], %[[C1]]
// CHECK:      case 1
// CHECK-NEXT:   scf.yield %[[C6]], %[[C1]]
// CHECK:      default
// CHECK-NEXT:   scf.yield %[[POISON]], %[[C0]]
// CHECK:      cf.switch %[[INDEX_SWITCH]]#1
// CHECK-NEXT: default: ^[[BB2:[[:alnum:]]+]]
// CHECK-SAME: %[[INDEX_SWITCH]]#0
// CHECK-NEXT: 0: ^[[BB1:[[:alnum:]]+]]
// CHECK-NEXT: ]

// CHECK: ^[[BB2]]{{.*}}:
// CHECK: scf.while
// CHECK-NOT: cf.{{(switch|(cond_)?br)}}
// CHECK: return

// CHECK: ^[[BB1]]:
// CHECK-NEXT: "test.returnLike"

// -----

func.func @select_like(%cond: i1) -> i32 {
  %0 = arith.constant 0 : i32
  %1 = arith.constant 1 : i32
  cf.cond_br %cond, ^bb0(%0 : i32), ^bb0(%1 : i32)
^bb0(%arg: i32):
  return %arg : i32
}

// CHECK-LABEL: func @select_like
// CHECK-SAME: %[[COND:.*]]: i1
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-NEXT: %[[RES:.*]] = scf.if %[[COND]]
// CHECK-NEXT:   scf.yield %[[C0]]
// CHECK-NEXT: else
// CHECK-NEXT:   scf.yield %[[C1]]
// CHECK:      return %[[RES]]

// -----

func.func @return_like_dominated_by_condition(%cond1: i1, %cond2: i1, %cond3: i1) {
  cf.cond_br %cond1, ^bb1, ^bb2

^bb1:
  return

^bb2:
  cf.cond_br %cond2, ^bb3, ^bb4

^bb3:
  "test.unreachable"() : () -> ()

^bb4:
  cf.cond_br %cond3, ^bb3, ^bb5

^bb5:
  return
}

// CHECK-LABEL: func @return_like_dominated_by_condition
// CHECK-SAME: %[[COND1:[[:alnum:]]+]]
// CHECK-SAME: %[[COND2:[[:alnum:]]+]]
// CHECK-SAME: %[[COND3:[[:alnum:]]+]]
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK: %[[IF:.*]] = scf.if %[[COND1]]
// CHECK-NEXT:   scf.yield
// CHECK: else
// CHECK:   scf.if %[[COND2]]
// CHECK-NEXT:   scf.yield
// CHECK:   else
// CHECK:      scf.if %[[COND3]]
// CHECK-NEXT:    scf.yield
// CHECK-NEXT: else
// CHECK-NEXT:    scf.yield

// CHECK: cf.switch %[[IF]]
// CHECK-NEXT: default: ^[[BB1:.*]],
// CHECK-NEXT: 0: ^[[BB2:[[:alnum:]]+]]

// CHECK: ^[[BB2]]:
// CHECK-NEXT: return

// CHECK: ^[[BB1]]:
// CHECK-NEXT: "test.unreachable"

// -----

func.func @dominator_issue(%cond: i1, %cond2: i1) -> i32 {
  cf.cond_br %cond, ^bb1, ^bb2

^bb1:
  "test.unreachable"() : () -> ()

^bb2:
  %value = "test.def"() : () -> i32
  cf.cond_br %cond2, ^bb1, ^bb4

^bb4:
  return %value : i32
}

// CHECK-LABEL: func @dominator_issue
// CHECK-SAME: %[[COND1:[[:alnum:]]+]]
// CHECK-SAME: %[[COND2:[[:alnum:]]+]]
// CHECK: %[[IF:.*]]:2 = scf.if %[[COND1]]
// CHECK: else
// CHECK:   %[[VALUE:.*]] = "test.def"
// CHECK:   %[[IF_RES:.*]]:2 = scf.if %[[COND2]]
// CHECK:   else
// CHECK-NEXT: scf.yield %[[VALUE]]
// CHECK:   scf.yield %[[IF_RES]]#0
// CHECK: cf.switch %[[IF]]#1
// CHECK-NEXT: default: ^[[BB2:[[:alnum:]]+]](
// CHECK-SAME: %[[IF]]#0
// CHECK-NEXT: 0: ^[[BB1:[[:alnum:]]+]]
// CHECK: ^[[BB1]]:
// CHECK-NEXT: "test.unreachable"
// CHECK: ^[[BB2]]
// CHECK-SAME: %[[ARG:[[:alnum:]]+]]
// CHECK-NEXT: return %[[ARG]]

// -----

// Test that %value gets properly passed to ^bb4.

func.func private @bar(i32)

func.func @dominator_issue_loop(%cond: i1, %cond2: i1) -> i32 {
  %0 = arith.constant 5 : i32
  cf.br ^bb0

^bb0:
  cf.cond_br %cond, ^bb1, ^bb3

^bb1:
  %value = "test.def"() : () -> i32
  cf.cond_br %cond2, ^bb0, ^bb4

^bb3:
  return %0 : i32

^bb4:
  return %value : i32
}

// CHECK-LABEL: func @dominator_issue_loop
// CHECK-SAME: %[[COND1:[[:alnum:]]+]]
// CHECK-SAME: %[[COND2:[[:alnum:]]+]]
// CHECK: %[[WHILE:.*]]:2 = scf.while
// CHECK:   %[[IF:.*]]:3 = scf.if %[[COND1]]
// CHECK:     %[[DEF:.*]] = "test.def"
// CHECK:     %[[IF2:.*]]:3 = scf.if %[[COND2]]
// CHECK:       scf.yield
// CHECK-SAME:   %[[DEF]]
// CHECK:     else
// CHECK:       scf.yield %{{.*}}, %{{.*}}, %[[DEF]]
// CHECK:     scf.yield %[[IF2]]#0, %[[IF2]]#1, %[[IF2]]#2
// CHECK:   scf.condition(%{{.*}}) %[[IF]]#2, %[[IF]]#0

// CHECK: %[[SWITCH:.*]] = scf.index_switch
// CHECK:   scf.yield %[[WHILE]]#0
// CHECK: return %[[SWITCH]]

// -----

// Multi entry loops generally produce code in dire need of canonicalization.

func.func private @comp1(%arg: i32) -> i1
func.func private @comp2(%arg: i32) -> i1
func.func private @foo(%arg: i32)

func.func @multi_entry_loop(%cond: i1) {
  %0 = arith.constant 6 : i32
  %1 = arith.constant 5 : i32
  cf.cond_br %cond, ^bb0, ^bb1

^bb0:
  %exit = call @comp1(%0) : (i32) -> i1
  cf.cond_br %exit, ^bb2(%0 : i32), ^bb1

^bb1:
  %exit2 = call @comp2(%1) : (i32) -> i1
  cf.cond_br %exit2, ^bb2(%1 : i32), ^bb0

^bb2(%arg3 : i32):
  call @foo(%arg3) : (i32) -> ()
  return
}

// CHECK-LABEL: func @multi_entry_loop
// CHECK-SAME: %[[ARG0:[[:alnum:]]+]]
// CHECK-DAG: %[[C0:.*]] = arith.constant 0
// CHECK-DAG: %[[UB:.*]] = ub.poison
// CHECK-DAG: %[[C1:.*]] = arith.constant 1
// CHECK-DAG: %[[C6:.*]] = arith.constant 6
// CHECK-DAG: %[[C5:.*]] = arith.constant 5
// CHECK:      %[[IF:.*]]:{{.*}} = scf.if %[[ARG0]]
// CHECK-NEXT:   scf.yield %[[C1]], %[[UB]]
// CHECK-NEXT: else
// CHECK-NEXT:   scf.yield %[[C0]], %[[UB]]
// CHECK:      %[[WHILE:.*]]:{{.*}} = scf.while
// CHECK-SAME: %[[ARG1:.*]] = %[[IF]]#0
// CHECK-SAME: %[[ARG2:.*]] = %[[IF]]#1
// CHECK-NEXT:   %[[FLAG:.*]] = arith.index_castui %[[ARG1]]
// CHECK-NEXT:   %[[SWITCH:.*]]:{{.*}} = scf.index_switch %[[FLAG]]
// CHECK-NEXT:   case 0
// CHECK-NEXT:     %[[EXIT:.*]] = func.call @comp2(%[[C5]])
// CHECK-NEXT:     %[[IF_RES:.*]]:{{.*}} = scf.if %[[EXIT]]
// CHECK-NEXT:       scf.yield %[[UB]], %[[C5]], %[[C1]], %[[C0]]
// CHECK-NEXT:     else
// CHECK-NEXT:       scf.yield %[[C1]], %[[UB]], %[[C0]], %[[C1]]
// CHECK:          scf.yield %[[IF_RES]]#0, %[[IF_RES]]#1, %[[IF_RES]]#2, %[[IF_RES]]#3
// CHECK:        default
// CHECK-NEXT:     %[[EXIT:.*]] = func.call @comp1(%[[C6]])
// CHECK-NEXT:     %[[IF_RES:.*]]:{{.*}} = scf.if %[[EXIT]]
// CHECK-NEXT:       scf.yield %[[UB]], %[[C6]], %[[C1]], %[[C0]]
// CHECK-NEXT:     else
// CHECK-NEXT:       scf.yield %[[C0]], %[[UB]], %[[C0]], %[[C1]]
// CHECK:          scf.yield %[[IF_RES]]#0, %[[IF_RES]]#1, %[[IF_RES]]#2, %[[IF_RES]]#3
// CHECK:        %[[COND:.*]] = arith.trunci %[[SWITCH]]#3
// CHECK-NEXT:   scf.condition(%[[COND]]) %[[SWITCH]]#0, %[[SWITCH]]#1
// CHECK:      do
// CHECK:        scf.yield
// CHECK:      call @foo(%[[WHILE]]#1)
// CHECK-NEXT: return

// -----

func.func @nested_region() {
  scf.execute_region {
    %cond = "test.test1"() : () -> i1
    cf.cond_br %cond, ^bb1, ^bb2
  ^bb1:
    "test.test2"() : () -> ()
    cf.br ^bb3
  ^bb2:
    "test.test3"() : () -> ()
    cf.br ^bb3
  ^bb3:
    "test.test4"() : () -> ()
    scf.yield
  }
  return
}

// CHECK-LABEL: func @nested_region
// CHECK:      scf.execute_region {
// CHECK:      %[[COND:.*]] = "test.test1"()
// CHECK-NEXT: scf.if %[[COND]]
// CHECK-NEXT:   "test.test2"()
// CHECK-NEXT: else
// CHECK-NEXT:   "test.test3"()
// CHECK-NEXT: }
// CHECK-NEXT: "test.test4"()
// CHECK-NEXT: scf.yield
// CHECK-NEXT: }
// CHECK-NEXT: return

// -----

func.func @nested_region_inside_loop_use() {
  cf.br ^bb1

^bb1:
  %3 = "test.test1"() : () -> i32
  scf.execute_region {
    "test.foo"(%3) : (i32) -> ()
    scf.yield
  }
  cf.br ^bb1
}

// CHECK-LABEL: func @nested_region_inside_loop_use
// CHECK: scf.while
// CHECK-NEXT: %[[DEF:.*]] = "test.test1"()
// CHECK-NEXT: scf.execute_region
// CHECK-NEXT: "test.foo"(%[[DEF]])

// -----

func.func @nested_region_outside_loop_use() {
  cf.br ^bb1

^bb1:
  %3 = "test.test1"() : () -> i32
  %cond = "test.test2"() : () -> i1
  cf.cond_br %cond, ^bb1, ^bb2

^bb2:
  scf.execute_region {
    "test.foo"(%3) : (i32) -> ()
    scf.yield
  }
  return
}

// CHECK-LABEL: func @nested_region_outside_loop_use
// CHECK: %[[RES:.*]] = scf.while
// CHECK: %[[DEF:.*]] = "test.test1"()
// CHECK: scf.condition(%{{.*}}) %[[DEF]]

// CHECK: scf.execute_region
// CHECK-NEXT: "test.foo"(%[[RES]])