// RUN: mlir-opt -allow-unregistered-dialect -convert-scf-to-emitc %s | FileCheck %s
// RUN: mlir-opt -allow-unregistered-dialect -convert-to-emitc="filter-dialects=scf" %s | FileCheck %s

emitc.func @payload_one_result(%arg: i32) -> i32 {
  %result = add %arg, %arg : (i32, i32) -> i32
  return %result : i32
}

func.func @one_result() -> i32 {
  %init = emitc.literal "1.0" : i32
  %var  = emitc.literal "1.0" : i32
  %exit = emitc.literal "10.0" : i32

  %res = scf.while (%arg1 = %init) : (i32) -> i32 {
    %sum = emitc.add %arg1, %var : (i32, i32) -> i32
    %condition = emitc.cmp lt, %sum, %exit : (i32, i32) -> i1
    %next = emitc.add %arg1, %arg1 : (i32, i32) -> i32
    scf.condition(%condition) %next : i32
  } do {
  ^bb0(%arg2: i32):
    %next_arg1 = emitc.call @payload_one_result(%arg2) : (i32) -> i32
    scf.yield %next_arg1 : i32
  }
  
  return %res : i32
}
// CHECK-LABEL:   emitc.func @payload_one_result(
// CHECK-SAME:      %[[ARG0:.*]]: i32) -> i32 {
// CHECK:           %[[VAL_0:.*]] = add %[[ARG0]], %[[ARG0]] : (i32, i32) -> i32
// CHECK:           return %[[VAL_0]] : i32
// CHECK:         }

// CHECK-LABEL:   func.func @one_result() -> i32 {
// CHECK:           %[[VAL_0:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_1:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_2:.*]] = emitc.literal "10.0" : i32
// CHECK:           %[[VAL_3:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           emitc.assign %[[VAL_0]] : i32 to %[[VAL_4]] : <i32>
// CHECK:           %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i1>
// CHECK:           emitc.do {
// CHECK:             %[[VAL_6:.*]] = load %[[VAL_4]] : <i32>
// CHECK:             %[[VAL_7:.*]] = add %[[VAL_6]], %[[VAL_1]] : (i32, i32) -> i32
// CHECK:             %[[VAL_8:.*]] = cmp lt, %[[VAL_7]], %[[VAL_2]] : (i32, i32) -> i1
// CHECK:             %[[VAL_9:.*]] = add %[[VAL_6]], %[[VAL_6]] : (i32, i32) -> i32
// CHECK:             assign %[[VAL_9]] : i32 to %[[VAL_3]] : <i32>
// CHECK:             assign %[[VAL_8]] : i1 to %[[VAL_5]] : <i1>
// CHECK:             if %[[VAL_8]] {
// CHECK:               %[[VAL_10:.*]] = call @payload_one_result(%[[VAL_9]]) : (i32) -> i32
// CHECK:               assign %[[VAL_10]] : i32 to %[[VAL_4]] : <i32>
// CHECK:             }
// CHECK:           } while {
// CHECK:             %[[VAL_11:.*]] = expression %[[VAL_5]] : (!emitc.lvalue<i1>) -> i1 {
// CHECK:               %[[VAL_12:.*]] = load %[[VAL_5]] : <i1>
// CHECK:               yield %[[VAL_12]] : i1
// CHECK:             }
// CHECK:             yield %[[VAL_11]] : i1
// CHECK:           }
// CHECK:           %[[VAL_13:.*]] = emitc.load %[[VAL_3]] : <i32>
// CHECK:           return %[[VAL_13]] : i32
// CHECK:         }

emitc.func @payload_two_results(%arg: i32) -> i32 {
  %result = add %arg, %arg : (i32, i32) -> i32
  return %result : i32
}

func.func @two_results() -> i32 {
  %init = emitc.literal "1.0" : i32
  %exit = emitc.literal "10.0" : i32

  %res1, %res2 = scf.while (%arg1_1 = %init, %arg1_2 = %init) : (i32, i32) -> (i32, i32) {
    %sum = emitc.add %arg1_1, %arg1_2 : (i32, i32) -> i32
    %condition = emitc.cmp lt, %sum, %exit : (i32, i32) -> i1
    scf.condition(%condition) %init, %arg1_2  : i32, i32
  } do {
  ^bb0(%arg2_1 : i32, %arg2_2 : i32):
    %next1 = emitc.call @payload_two_results(%arg2_1) : (i32) -> i32
    %next2 = emitc.call @payload_two_results(%arg2_2) : (i32) -> i32
    scf.yield %next1, %next2 : i32, i32
  }
  
  return %res1 : i32
}
// CHECK-LABEL:   emitc.func @payload_two_results(
// CHECK-SAME:      %[[ARG0:.*]]: i32) -> i32 {
// CHECK:           %[[VAL_0:.*]] = add %[[ARG0]], %[[ARG0]] : (i32, i32) -> i32
// CHECK:           return %[[VAL_0]] : i32
// CHECK:         }

// CHECK-LABEL:   func.func @two_results() -> i32 {
// CHECK:           %[[VAL_0:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_1:.*]] = emitc.literal "10.0" : i32
// CHECK:           %[[VAL_2:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_3:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           emitc.assign %[[VAL_0]] : i32 to %[[VAL_4]] : <i32>
// CHECK:           %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           emitc.assign %[[VAL_0]] : i32 to %[[VAL_5]] : <i32>
// CHECK:           %[[VAL_6:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i1>
// CHECK:           emitc.do {
// CHECK:             %[[VAL_7:.*]] = load %[[VAL_4]] : <i32>
// CHECK:             %[[VAL_8:.*]] = load %[[VAL_5]] : <i32>
// CHECK:             %[[VAL_9:.*]] = add %[[VAL_7]], %[[VAL_8]] : (i32, i32) -> i32
// CHECK:             %[[VAL_10:.*]] = cmp lt, %[[VAL_9]], %[[VAL_1]] : (i32, i32) -> i1
// CHECK:             assign %[[VAL_0]] : i32 to %[[VAL_2]] : <i32>
// CHECK:             assign %[[VAL_8]] : i32 to %[[VAL_3]] : <i32>
// CHECK:             assign %[[VAL_10]] : i1 to %[[VAL_6]] : <i1>
// CHECK:             if %[[VAL_10]] {
// CHECK:               %[[VAL_11:.*]] = call @payload_two_results(%[[VAL_0]]) : (i32) -> i32
// CHECK:               %[[VAL_12:.*]] = call @payload_two_results(%[[VAL_8]]) : (i32) -> i32
// CHECK:               assign %[[VAL_11]] : i32 to %[[VAL_4]] : <i32>
// CHECK:               assign %[[VAL_12]] : i32 to %[[VAL_5]] : <i32>
// CHECK:             }
// CHECK:           } while {
// CHECK:             %[[VAL_13:.*]] = expression %[[VAL_6]] : (!emitc.lvalue<i1>) -> i1 {
// CHECK:               %[[VAL_14:.*]] = load %[[VAL_6]] : <i1>
// CHECK:               yield %[[VAL_14]] : i1
// CHECK:             }
// CHECK:             yield %[[VAL_13]] : i1
// CHECK:           }
// CHECK:           %[[VAL_15:.*]] = emitc.load %[[VAL_2]] : <i32>
// CHECK:           %[[VAL_16:.*]] = emitc.load %[[VAL_3]] : <i32>
// CHECK:           return %[[VAL_15]] : i32
// CHECK:         }

emitc.func @payload_double_use(%arg: i32) -> i32 {
  %result = add %arg, %arg : (i32, i32) -> i32
  return %result : i32
}

emitc.func @foo_with_side_effect(%arg: i32, %p : !emitc.ptr<i32>) -> i32 {
  %sum = add %arg, %arg : (i32, i32) -> i32
  emitc.verbatim "{}[0] = {};" args %p, %sum : !emitc.ptr<i32>, i32
  return %sum : i32
}

func.func @double_use(%p : !emitc.ptr<i32>) -> i32 {
  %init = emitc.literal "1.0" : i32
  %var  = emitc.literal "1.0" : i32
  %exit = emitc.literal "10.0" : i32
  %res = scf.while (%arg1 = %init) : (i32) -> i32 {
    %used_twice = emitc.call @foo_with_side_effect(%arg1, %p) : (i32, !emitc.ptr<i32>) -> i32
    %prod = emitc.add %used_twice, %used_twice : (i32, i32) -> i32
    %sum = emitc.add %arg1, %prod : (i32, i32) -> i32
    %condition = emitc.cmp lt, %sum, %exit : (i32, i32) -> i1
    scf.condition(%condition) %arg1 : i32
  } do {
  ^bb0(%arg2: i32):
    %next_arg1 = emitc.call @payload_double_use(%arg2) : (i32) -> i32
    scf.yield %next_arg1 : i32
  }
  return %res : i32
}
// CHECK-LABEL:   emitc.func @payload_double_use(
// CHECK-SAME:      %[[ARG0:.*]]: i32) -> i32 {
// CHECK:           %[[VAL_0:.*]] = add %[[ARG0]], %[[ARG0]] : (i32, i32) -> i32
// CHECK:           return %[[VAL_0]] : i32
// CHECK:         }

// CHECK-LABEL:   emitc.func @foo_with_side_effect(
// CHECK-SAME:      %[[ARG0:.*]]: i32,
// CHECK-SAME:      %[[ARG1:.*]]: !emitc.ptr<i32>) -> i32 {
// CHECK:           %[[VAL_0:.*]] = add %[[ARG0]], %[[ARG0]] : (i32, i32) -> i32
// CHECK:           verbatim "{}[0] = {};" args %[[ARG1]], %[[VAL_0]] : !emitc.ptr<i32>, i32
// CHECK:           return %[[VAL_0]] : i32
// CHECK:         }

// CHECK-LABEL:   func.func @double_use(
// CHECK-SAME:      %[[ARG0:.*]]: !emitc.ptr<i32>) -> i32 {
// CHECK:           %[[VAL_0:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_1:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_2:.*]] = emitc.literal "10.0" : i32
// CHECK:           %[[VAL_3:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           emitc.assign %[[VAL_0]] : i32 to %[[VAL_4]] : <i32>
// CHECK:           %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i1>
// CHECK:           emitc.do {
// CHECK:             %[[VAL_6:.*]] = load %[[VAL_4]] : <i32>
// CHECK:             %[[VAL_7:.*]] = call @foo_with_side_effect(%[[VAL_6]], %[[ARG0]]) : (i32, !emitc.ptr<i32>) -> i32
// CHECK:             %[[VAL_8:.*]] = add %[[VAL_7]], %[[VAL_7]] : (i32, i32) -> i32
// CHECK:             %[[VAL_9:.*]] = add %[[VAL_6]], %[[VAL_8]] : (i32, i32) -> i32
// CHECK:             %[[VAL_10:.*]] = cmp lt, %[[VAL_9]], %[[VAL_2]] : (i32, i32) -> i1
// CHECK:             assign %[[VAL_6]] : i32 to %[[VAL_3]] : <i32>
// CHECK:             assign %[[VAL_10]] : i1 to %[[VAL_5]] : <i1>
// CHECK:             if %[[VAL_10]] {
// CHECK:               %[[VAL_11:.*]] = call @payload_double_use(%[[VAL_6]]) : (i32) -> i32
// CHECK:               assign %[[VAL_11]] : i32 to %[[VAL_4]] : <i32>
// CHECK:             }
// CHECK:           } while {
// CHECK:             %[[VAL_12:.*]] = expression %[[VAL_5]] : (!emitc.lvalue<i1>) -> i1 {
// CHECK:               %[[VAL_13:.*]] = load %[[VAL_5]] : <i1>
// CHECK:               yield %[[VAL_13]] : i1
// CHECK:             }
// CHECK:             yield %[[VAL_12]] : i1
// CHECK:           }
// CHECK:           %[[VAL_14:.*]] = emitc.load %[[VAL_3]] : <i32>
// CHECK:           return %[[VAL_14]] : i32
// CHECK:         }

emitc.func @payload_empty_after_region() -> i1 {
  %true = emitc.literal "true" : i1
  return %true : i1
}

func.func @empty_after_region() {
  scf.while () : () -> () {
    %condition = emitc.call @payload_empty_after_region() : () -> i1
    scf.condition(%condition)
  } do {
  ^bb0():
    scf.yield
  }
  return
}
// CHECK-LABEL:   emitc.func @payload_empty_after_region() -> i1 {
// CHECK:           %[[VAL_0:.*]] = literal "true" : i1
// CHECK:           return %[[VAL_0]] : i1
// CHECK:         }

// CHECK-LABEL:   func.func @empty_after_region() {
// CHECK:           %[[VAL_0:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i1>
// CHECK:           emitc.do {
// CHECK:             %[[VAL_1:.*]] = call @payload_empty_after_region() : () -> i1
// CHECK:             assign %[[VAL_1]] : i1 to %[[VAL_0]] : <i1>
// CHECK:           } while {
// CHECK:             %[[VAL_2:.*]] = expression %[[VAL_0]] : (!emitc.lvalue<i1>) -> i1 {
// CHECK:               %[[VAL_3:.*]] = load %[[VAL_0]] : <i1>
// CHECK:               yield %[[VAL_3]] : i1
// CHECK:             }
// CHECK:             yield %[[VAL_2]] : i1
// CHECK:           }
// CHECK:           return
// CHECK:         }

emitc.func @payload_different_number_of_vars(%arg0: i32) -> i32 {
  %0 = add %arg0, %arg0 : (i32, i32) -> i32
  return %0 : i32
}
func.func @different_number_of_vars() -> (i32, i32) {
  %init = emitc.literal "1.0" : i32
  %var  = emitc.literal "7.0" : i32
  %exit = emitc.literal "10.0" : i32
  %res, %res2 = scf.while (%arg1 = %init) : (i32) -> (i32, i32) {
    %sum = emitc.add %arg1, %var : (i32, i32) -> i32
    %condition = emitc.cmp lt, %sum, %exit : (i32, i32) -> i1
    %next = emitc.add %arg1, %arg1 : (i32, i32) -> i32
    scf.condition(%condition) %next, %sum : i32, i32
  } do {
  ^bb0(%arg2: i32, %arg3 : i32):
    %next_arg1 = emitc.call @payload_different_number_of_vars(%arg2) : (i32) -> i32
    scf.yield %next_arg1 : i32
  }
  return %res, %res2 : i32, i32
}
// CHECK-LABEL:   emitc.func @payload_different_number_of_vars(
// CHECK-SAME:      %[[ARG0:.*]]: i32) -> i32 {
// CHECK:           %[[VAL_0:.*]] = add %[[ARG0]], %[[ARG0]] : (i32, i32) -> i32
// CHECK:           return %[[VAL_0]] : i32
// CHECK:         }

// CHECK-LABEL:   func.func @different_number_of_vars() -> (i32, i32) {
// CHECK:           %[[VAL_0:.*]] = emitc.literal "1.0" : i32
// CHECK:           %[[VAL_1:.*]] = emitc.literal "7.0" : i32
// CHECK:           %[[VAL_2:.*]] = emitc.literal "10.0" : i32
// CHECK:           %[[VAL_3:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
// CHECK:           emitc.assign %[[VAL_0]] : i32 to %[[VAL_5]] : <i32>
// CHECK:           %[[VAL_6:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i1>
// CHECK:           emitc.do {
// CHECK:             %[[VAL_7:.*]] = load %[[VAL_5]] : <i32>
// CHECK:             %[[VAL_8:.*]] = add %[[VAL_7]], %[[VAL_1]] : (i32, i32) -> i32
// CHECK:             %[[VAL_9:.*]] = cmp lt, %[[VAL_8]], %[[VAL_2]] : (i32, i32) -> i1
// CHECK:             %[[VAL_10:.*]] = add %[[VAL_7]], %[[VAL_7]] : (i32, i32) -> i32
// CHECK:             assign %[[VAL_10]] : i32 to %[[VAL_3]] : <i32>
// CHECK:             assign %[[VAL_8]] : i32 to %[[VAL_4]] : <i32>
// CHECK:             assign %[[VAL_9]] : i1 to %[[VAL_6]] : <i1>
// CHECK:             if %[[VAL_9]] {
// CHECK:               %[[VAL_11:.*]] = call @payload_different_number_of_vars(%[[VAL_10]]) : (i32) -> i32
// CHECK:               assign %[[VAL_11]] : i32 to %[[VAL_5]] : <i32>
// CHECK:             }
// CHECK:           } while {
// CHECK:             %[[VAL_12:.*]] = expression %[[VAL_6]] : (!emitc.lvalue<i1>) -> i1 {
// CHECK:               %[[VAL_13:.*]] = load %[[VAL_6]] : <i1>
// CHECK:               yield %[[VAL_13]] : i1
// CHECK:             }
// CHECK:             yield %[[VAL_12]] : i1
// CHECK:           }
// CHECK:           %[[VAL_14:.*]] = emitc.load %[[VAL_3]] : <i32>
// CHECK:           %[[VAL_15:.*]] = emitc.load %[[VAL_4]] : <i32>
// CHECK:           return %[[VAL_14]], %[[VAL_15]] : i32, i32
// CHECK:         }