// RUN:   mlir-opt %s -pass-pipeline="builtin.module(func.func(test-expand-math,convert-arith-to-llvm),convert-vector-to-scf,convert-scf-to-cf,convert-cf-to-llvm,convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner                                                      \
// RUN:     -e main -entry-point-result=void -O0                               \
// RUN:     -shared-libs=%mlir_c_runner_utils  \
// RUN:     -shared-libs=%mlir_runner_utils    \
// RUN:     -shared-libs=%mlir_float16_utils   \
// RUN: | FileCheck %s

// -------------------------------------------------------------------------- //
// exp2f.
// -------------------------------------------------------------------------- //
func.func @func_exp2f(%a : f64) {
  %r = math.exp2 %a : f64
  vector.print %r : f64
  return
}

func.func @exp2f() {
  // CHECK: 2
  %a = arith.constant 1.0 : f64
  call @func_exp2f(%a) : (f64) -> ()  

  // CHECK-NEXT: 4
  %b = arith.constant 2.0 : f64
  call @func_exp2f(%b) : (f64) -> ()

  // CHECK-NEXT: 5.65685
  %c = arith.constant 2.5 : f64
  call @func_exp2f(%c) : (f64) -> ()

  // CHECK-NEXT: 0.29730
  %d = arith.constant -1.75 : f64
  call @func_exp2f(%d) : (f64) -> ()

  // CHECK-NEXT: 1.09581
  %e = arith.constant 0.132 : f64
  call @func_exp2f(%e) : (f64) -> ()

  // CHECK-NEXT: inf
  %f1 = arith.constant 0.00 : f64
  %f2 = arith.constant 1.00 : f64
  %f = arith.divf %f2, %f1 : f64
  call @func_exp2f(%f) : (f64) -> ()

  // CHECK-NEXT: inf
  %g = arith.constant 5038939.0 : f64
  call @func_exp2f(%g) : (f64) -> ()

  // CHECK-NEXT: 0
  %neg_inf = arith.constant 0xff80000000000000 : f64
  call @func_exp2f(%neg_inf) : (f64) -> ()

  // CHECK-NEXT: inf
  %i = arith.constant 0x7fc0000000000000 : f64
  call @func_exp2f(%i) : (f64) -> ()
  return
}

// -------------------------------------------------------------------------- //
// round.
// -------------------------------------------------------------------------- //
func.func @func_roundf(%a : f32) {
  %r = math.round %a : f32
  vector.print %r : f32
  return
}

func.func @func_roundf$bitcast_result_to_int(%a : f32) {
  %b = math.round %a : f32
  %c = arith.bitcast %b : f32 to i32
  vector.print %c : i32
  return
}

func.func @func_roundf$vector(%a : vector<1xf32>) {
  %b = math.round %a : vector<1xf32>
  vector.print %b : vector<1xf32>
  return
}

func.func @roundf() {
  // CHECK-NEXT: 4
  %a = arith.constant 3.8 : f32
  call @func_roundf(%a) : (f32) -> ()

  // CHECK-NEXT: -4
  %b = arith.constant -3.8 : f32
  call @func_roundf(%b) : (f32) -> ()

  // CHECK-NEXT: -4
  %c = arith.constant -4.2 : f32
  call @func_roundf(%c) : (f32) -> ()

  // CHECK-NEXT: -495
  %d = arith.constant -495.0 : f32
  call @func_roundf(%d) : (f32) -> ()

  // CHECK-NEXT: 495
  %e = arith.constant 495.0 : f32
  call @func_roundf(%e) : (f32) -> ()

  // CHECK-NEXT: 9
  %f = arith.constant 8.5 : f32
  call @func_roundf(%f) : (f32) -> ()

  // CHECK-NEXT: -9
  %g = arith.constant -8.5 : f32
  call @func_roundf(%g) : (f32) -> ()

  // CHECK-NEXT: -0
  %h = arith.constant -0.4 : f32
  call @func_roundf(%h) : (f32) -> ()

  // Special values: 0, -0, inf, -inf, nan, -nan
  %cNeg0 = arith.constant -0.0 : f32
  %c0 = arith.constant 0.0 : f32
  %cInfInt = arith.constant 0x7f800000 : i32
  %cInf = arith.bitcast %cInfInt : i32 to f32
  %cNegInfInt = arith.constant 0xff800000 : i32
  %cNegInf = arith.bitcast %cNegInfInt : i32 to f32
  %cNanInt = arith.constant 0x7fc00000 : i32
  %cNan = arith.bitcast %cNanInt : i32 to f32
  %cNegNanInt = arith.constant 0xffc00000 : i32
  %cNegNan = arith.bitcast %cNegNanInt : i32 to f32

  // CHECK-NEXT: -0
  call @func_roundf(%cNeg0) : (f32) -> ()
  // CHECK-NEXT: 0
  call @func_roundf(%c0) : (f32) -> ()
  // CHECK-NEXT: inf
  call @func_roundf(%cInf) : (f32) -> ()
  // CHECK-NEXT: -inf
  call @func_roundf(%cNegInf) : (f32) -> ()
  // Per IEEE 754-2008, sign is not required when printing a negative NaN, so
  // print as an int to ensure input NaN is left unchanged.
  // CHECK-NEXT: 2143289344
  // CHECK-NEXT: 2143289344
  call @func_roundf$bitcast_result_to_int(%cNan) : (f32) -> ()
  vector.print %cNanInt : i32
  // CHECK-NEXT: -4194304
  // CHECK-NEXT: -4194304
  call @func_roundf$bitcast_result_to_int(%cNegNan) : (f32) -> ()
  vector.print %cNegNanInt : i32

  // Very large values (greater than INT_64_MAX)
  %c2To100 = arith.constant 1.268e30 : f32 // 2^100
  // CHECK-NEXT: 1.268e+30
  call @func_roundf(%c2To100) : (f32) -> ()

  // Values above and below 2^23 = 8388608
  %c8388606_5 = arith.constant 8388606.5 : f32
  %c8388607 = arith.constant 8388607.0 : f32
  %c8388607_5 = arith.constant 8388607.5 : f32
  %c8388608 = arith.constant 8388608.0 : f32
  %c8388609 = arith.constant 8388609.0 : f32

  // Bitcast result to int to avoid printing in scientific notation,
  // which does not display all significant digits.

  // CHECK-NEXT: 1258291198
  // hex: 0x4AFFFFFE
  call @func_roundf$bitcast_result_to_int(%c8388606_5) : (f32) -> ()
  // CHECK-NEXT: 1258291198
  // hex: 0x4AFFFFFE
  call @func_roundf$bitcast_result_to_int(%c8388607) : (f32) -> ()
  // CHECK-NEXT: 1258291200
  // hex: 0x4B000000
  call @func_roundf$bitcast_result_to_int(%c8388607_5) : (f32) -> ()
  // CHECK-NEXT: 1258291200
  // hex: 0x4B000000
  call @func_roundf$bitcast_result_to_int(%c8388608) : (f32) -> ()
  // CHECK-NEXT: 1258291201
  // hex: 0x4B000001
  call @func_roundf$bitcast_result_to_int(%c8388609) : (f32) -> ()

  // Check that vector type works
  %cVec = arith.constant dense<[0.5]> : vector<1xf32>
  // CHECK-NEXT: ( 1 )
  call @func_roundf$vector(%cVec) : (vector<1xf32>) -> ()

  return
}

// -------------------------------------------------------------------------- //
// pow.
// -------------------------------------------------------------------------- //
func.func @func_powff64(%a : f64, %b : f64) {
  %r = math.powf %a, %b : f64
  vector.print %r : f64
  return
}

func.func @func_powff32(%a : f32, %b : f32) {
  %r = math.powf %a, %b : f32
  vector.print %r : f32
  return
}

func.func @powf() {
  // CHECK-NEXT: 16
  %a   = arith.constant 4.0 : f64
  %a_p = arith.constant 2.0 : f64
  call @func_powff64(%a, %a_p) : (f64, f64) -> ()

  // CHECK-NEXT: -27
  %b   = arith.constant -3.0 : f64
  %b_p = arith.constant 3.0 : f64
  call @func_powff64(%b, %b_p) : (f64, f64) -> ()

  // CHECK-NEXT: 2.343
  %c   = arith.constant 2.343 : f64
  %c_p = arith.constant 1.000 : f64
  call @func_powff64(%c, %c_p) : (f64, f64) -> ()

  // CHECK-NEXT: 0.176171
  %d   = arith.constant 4.25 : f64
  %d_p = arith.constant -1.2  : f64
  call @func_powff64(%d, %d_p) : (f64, f64) -> ()

  // CHECK-NEXT: 1
  %e   = arith.constant 4.385 : f64
  %e_p = arith.constant 0.00 : f64
  call @func_powff64(%e, %e_p) : (f64, f64) -> ()

  // CHECK-NEXT: 6.62637
  %f    = arith.constant 4.835 : f64
  %f_p  = arith.constant 1.2 : f64
  call @func_powff64(%f, %f_p) : (f64, f64) -> ()

  // CHECK-NEXT: nan
  %i = arith.constant 1.0 : f64
  %h = arith.constant 0x7fffffffffffffff : f64
  call @func_powff64(%i, %h) : (f64, f64) -> ()

  // CHECK-NEXT: inf
  %j   = arith.constant 29385.0 : f64
  %j_p = arith.constant 23598.0 : f64
  call @func_powff64(%j, %j_p) : (f64, f64) -> ()

  // CHECK-NEXT: -nan
  %k = arith.constant 1.0 : f64
  %k_p = arith.constant 0xfff0000001000000 : f64
  call @func_powff64(%k, %k_p) : (f64, f64) -> ()  

  // CHECK-NEXT: -nan
  %l = arith.constant 1.0 : f32
  %l_p = arith.constant 0xffffffff : f32
  call @func_powff32(%l, %l_p) : (f32, f32) -> ()  
  return  
}

// -------------------------------------------------------------------------- //
// roundeven.
// -------------------------------------------------------------------------- //

func.func @func_roundeven32(%a : f32) {
  %b = math.roundeven %a : f32
  vector.print %b : f32
  return
}

func.func @func_roundeven32$bitcast_result_to_int(%a : f32) {
  %b = math.roundeven %a : f32
  %c = arith.bitcast %b : f32 to i32
  vector.print %c : i32
  return
}

func.func @func_roundeven32$vector(%a : vector<1xf32>) {
  %b = math.roundeven %a : vector<1xf32>
  vector.print %b : vector<1xf32>
  return
}

func.func @roundeven32() {
  %c0_25 = arith.constant 0.25 : f32
  %c0_5 = arith.constant 0.5 : f32
  %c0_75 = arith.constant 0.75 : f32
  %c1 = arith.constant 1.0 : f32
  %c1_25 = arith.constant 1.25 : f32
  %c1_5 = arith.constant 1.5 : f32
  %c1_75 = arith.constant 1.75 : f32
  %c2 = arith.constant 2.0 : f32
  %c2_25 = arith.constant 2.25 : f32
  %c2_5 = arith.constant 2.5 : f32
  %c2_75 = arith.constant 2.75 : f32
  %c3 = arith.constant 3.0 : f32
  %c3_25 = arith.constant 3.25 : f32
  %c3_5 = arith.constant 3.5 : f32
  %c3_75 = arith.constant 3.75 : f32

  %cNeg0_25 = arith.constant -0.25 : f32
  %cNeg0_5 = arith.constant -0.5 : f32
  %cNeg0_75 = arith.constant -0.75 : f32
  %cNeg1 = arith.constant -1.0 : f32
  %cNeg1_25 = arith.constant -1.25 : f32
  %cNeg1_5 = arith.constant -1.5 : f32
  %cNeg1_75 = arith.constant -1.75 : f32
  %cNeg2 = arith.constant -2.0 : f32
  %cNeg2_25 = arith.constant -2.25 : f32
  %cNeg2_5 = arith.constant -2.5 : f32
  %cNeg2_75 = arith.constant -2.75 : f32
  %cNeg3 = arith.constant -3.0 : f32
  %cNeg3_25 = arith.constant -3.25 : f32
  %cNeg3_5 = arith.constant -3.5 : f32
  %cNeg3_75 = arith.constant -3.75 : f32

  // CHECK-NEXT: 0
  call @func_roundeven32(%c0_25) : (f32) -> ()
  // CHECK-NEXT: 0
  call @func_roundeven32(%c0_5) : (f32) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven32(%c0_75) : (f32) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven32(%c1) : (f32) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven32(%c1_25) : (f32) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven32(%c1_5) : (f32) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven32(%c1_75) : (f32) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven32(%c2) : (f32) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven32(%c2_25) : (f32) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven32(%c2_5) : (f32) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven32(%c2_75) : (f32) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven32(%c3) : (f32) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven32(%c3_25) : (f32) -> ()
  // CHECK-NEXT: 4
  call @func_roundeven32(%c3_5) : (f32) -> ()
  // CHECK-NEXT: 4
  call @func_roundeven32(%c3_75) : (f32) -> ()

  // CHECK-NEXT: -0
  call @func_roundeven32(%cNeg0_25) : (f32) -> ()
  // CHECK-NEXT: -0
  call @func_roundeven32(%cNeg0_5) : (f32) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven32(%cNeg0_75) : (f32) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven32(%cNeg1) : (f32) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven32(%cNeg1_25) : (f32) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven32(%cNeg1_5) : (f32) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven32(%cNeg1_75) : (f32) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven32(%cNeg2) : (f32) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven32(%cNeg2_25) : (f32) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven32(%cNeg2_5) : (f32) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven32(%cNeg2_75) : (f32) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven32(%cNeg3) : (f32) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven32(%cNeg3_25) : (f32) -> ()
  // CHECK-NEXT: -4
  call @func_roundeven32(%cNeg3_5) : (f32) -> ()
  // CHECK-NEXT: -4
  call @func_roundeven32(%cNeg3_75) : (f32) -> ()

  // Special values: 0, -0, inf, -inf, nan, -nan
  %cNeg0 = arith.constant -0.0 : f32
  %c0 = arith.constant 0.0 : f32
  %cInfInt = arith.constant 0x7f800000 : i32
  %cInf = arith.bitcast %cInfInt : i32 to f32
  %cNegInfInt = arith.constant 0xff800000 : i32
  %cNegInf = arith.bitcast %cNegInfInt : i32 to f32
  %cNanInt = arith.constant 0x7fc00000 : i32
  %cNan = arith.bitcast %cNanInt : i32 to f32
  %cNegNanInt = arith.constant 0xffc00000 : i32
  %cNegNan = arith.bitcast %cNegNanInt : i32 to f32

  // CHECK-NEXT: -0
  call @func_roundeven32(%cNeg0) : (f32) -> ()
  // CHECK-NEXT: 0
  call @func_roundeven32(%c0) : (f32) -> ()
  // CHECK-NEXT: inf
  call @func_roundeven32(%cInf) : (f32) -> ()
  // CHECK-NEXT: -inf
  call @func_roundeven32(%cNegInf) : (f32) -> ()
  // Per IEEE 754-2008, sign is not required when printing a negative NaN, so
  // print as an int to ensure input NaN is left unchanged.
  // CHECK-NEXT: 2143289344
  // CHECK-NEXT: 2143289344
  call @func_roundeven32$bitcast_result_to_int(%cNan) : (f32) -> ()
  vector.print %cNanInt : i32
  // CHECK-NEXT: -4194304
  // CHECK-NEXT: -4194304
  call @func_roundeven32$bitcast_result_to_int(%cNegNan) : (f32) -> ()
  vector.print %cNegNanInt : i32


  // Values above and below 2^23 = 8388608
  %c8388606_5 = arith.constant 8388606.5 : f32
  %c8388607 = arith.constant 8388607.0 : f32
  %c8388607_5 = arith.constant 8388607.5 : f32
  %c8388608 = arith.constant 8388608.0 : f32
  %c8388609 = arith.constant 8388609.0 : f32

  // Bitcast result to int to avoid printing in scientific notation,
  // which does not display all significant digits.

  // CHECK-NEXT: 1258291196
  // hex: 0x4AFFFFFC
  call @func_roundeven32$bitcast_result_to_int(%c8388606_5) : (f32) -> ()
  // CHECK-NEXT: 1258291198
  // hex: 0x4AFFFFFE
  call @func_roundeven32$bitcast_result_to_int(%c8388607) : (f32) -> ()
  // CHECK-NEXT: 1258291200
  // hex: 0x4B000000
  call @func_roundeven32$bitcast_result_to_int(%c8388607_5) : (f32) -> ()
  // CHECK-NEXT: 1258291200
  // hex: 0x4B000000
  call @func_roundeven32$bitcast_result_to_int(%c8388608) : (f32) -> ()
  // CHECK-NEXT: 1258291201
  // hex: 0x4B000001
  call @func_roundeven32$bitcast_result_to_int(%c8388609) : (f32) -> ()


  // Check that vector type works
  %cVec = arith.constant dense<[0.5]> : vector<1xf32>
  // CHECK-NEXT: ( 0 )
  call @func_roundeven32$vector(%cVec) : (vector<1xf32>) -> ()
  return
}

func.func @func_roundeven64(%a : f64) {
  %b = math.roundeven %a : f64
  vector.print %b : f64
  return
}

func.func @func_roundeven64$bitcast_result_to_int(%a : f64) {
  %b = math.roundeven %a : f64
  %c = arith.bitcast %b : f64 to i64
  vector.print %c : i64
  return
}

func.func @func_roundeven64$vector(%a : vector<1xf64>) {
  %b = math.roundeven %a : vector<1xf64>
  vector.print %b : vector<1xf64>
  return
}

func.func @roundeven64() {
  %c0_25 = arith.constant 0.25 : f64
  %c0_5 = arith.constant 0.5 : f64
  %c0_75 = arith.constant 0.75 : f64
  %c1 = arith.constant 1.0 : f64
  %c1_25 = arith.constant 1.25 : f64
  %c1_5 = arith.constant 1.5 : f64
  %c1_75 = arith.constant 1.75 : f64
  %c2 = arith.constant 2.0 : f64
  %c2_25 = arith.constant 2.25 : f64
  %c2_5 = arith.constant 2.5 : f64
  %c2_75 = arith.constant 2.75 : f64
  %c3 = arith.constant 3.0 : f64
  %c3_25 = arith.constant 3.25 : f64
  %c3_5 = arith.constant 3.5 : f64
  %c3_75 = arith.constant 3.75 : f64

  %cNeg0_25 = arith.constant -0.25 : f64
  %cNeg0_5 = arith.constant -0.5 : f64
  %cNeg0_75 = arith.constant -0.75 : f64
  %cNeg1 = arith.constant -1.0 : f64
  %cNeg1_25 = arith.constant -1.25 : f64
  %cNeg1_5 = arith.constant -1.5 : f64
  %cNeg1_75 = arith.constant -1.75 : f64
  %cNeg2 = arith.constant -2.0 : f64
  %cNeg2_25 = arith.constant -2.25 : f64
  %cNeg2_5 = arith.constant -2.5 : f64
  %cNeg2_75 = arith.constant -2.75 : f64
  %cNeg3 = arith.constant -3.0 : f64
  %cNeg3_25 = arith.constant -3.25 : f64
  %cNeg3_5 = arith.constant -3.5 : f64
  %cNeg3_75 = arith.constant -3.75 : f64

  // CHECK-NEXT: 0
  call @func_roundeven64(%c0_25) : (f64) -> ()
  // CHECK-NEXT: 0
  call @func_roundeven64(%c0_5) : (f64) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven64(%c0_75) : (f64) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven64(%c1) : (f64) -> ()
  // CHECK-NEXT: 1
  call @func_roundeven64(%c1_25) : (f64) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven64(%c1_5) : (f64) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven64(%c1_75) : (f64) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven64(%c2) : (f64) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven64(%c2_25) : (f64) -> ()
  // CHECK-NEXT: 2
  call @func_roundeven64(%c2_5) : (f64) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven64(%c2_75) : (f64) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven64(%c3) : (f64) -> ()
  // CHECK-NEXT: 3
  call @func_roundeven64(%c3_25) : (f64) -> ()
  // CHECK-NEXT: 4
  call @func_roundeven64(%c3_5) : (f64) -> ()
  // CHECK-NEXT: 4
  call @func_roundeven64(%c3_75) : (f64) -> ()

  // CHECK-NEXT: -0
  call @func_roundeven64(%cNeg0_25) : (f64) -> ()
  // CHECK-NEXT: -0
  call @func_roundeven64(%cNeg0_5) : (f64) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven64(%cNeg0_75) : (f64) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven64(%cNeg1) : (f64) -> ()
  // CHECK-NEXT: -1
  call @func_roundeven64(%cNeg1_25) : (f64) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven64(%cNeg1_5) : (f64) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven64(%cNeg1_75) : (f64) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven64(%cNeg2) : (f64) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven64(%cNeg2_25) : (f64) -> ()
  // CHECK-NEXT: -2
  call @func_roundeven64(%cNeg2_5) : (f64) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven64(%cNeg2_75) : (f64) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven64(%cNeg3) : (f64) -> ()
  // CHECK-NEXT: -3
  call @func_roundeven64(%cNeg3_25) : (f64) -> ()
  // CHECK-NEXT: -4
  call @func_roundeven64(%cNeg3_5) : (f64) -> ()
  // CHECK-NEXT: -4
  call @func_roundeven64(%cNeg3_75) : (f64) -> ()

  // Special values: 0, -0, inf, -inf, nan, -nan
  %cNeg0 = arith.constant -0.0 : f64
  %c0 = arith.constant 0.0 : f64
  %cInfInt = arith.constant 0x7FF0000000000000 : i64
  %cInf = arith.bitcast %cInfInt : i64 to f64
  %cNegInfInt = arith.constant 0xFFF0000000000000 : i64
  %cNegInf = arith.bitcast %cNegInfInt : i64 to f64
  %cNanInt = arith.constant 0x7FF0000000000001 : i64
  %cNan = arith.bitcast %cNanInt : i64 to f64
  %cNegNanInt = arith.constant 0xFFF0000000000001 : i64
  %cNegNan = arith.bitcast %cNegNanInt : i64 to f64

  // CHECK-NEXT: -0
  call @func_roundeven64(%cNeg0) : (f64) -> ()
  // CHECK-NEXT: 0
  call @func_roundeven64(%c0) : (f64) -> ()
  // CHECK-NEXT: inf
  call @func_roundeven64(%cInf) : (f64) -> ()
  // CHECK-NEXT: -inf
  call @func_roundeven64(%cNegInf) : (f64) -> ()

  // Values above and below 2^52 = 4503599627370496
  %c4503599627370494_5 = arith.constant 4503599627370494.5 : f64
  %c4503599627370495 = arith.constant 4503599627370495.0 : f64
  %c4503599627370495_5 = arith.constant 4503599627370495.5 : f64
  %c4503599627370496 = arith.constant 4503599627370496.0 : f64
  %c4503599627370497 = arith.constant 4503599627370497.0 : f64

  // Bitcast result to int to avoid printing in scientific notation,
  // which does not display all significant digits.

  // CHECK-NEXT: 4841369599423283196
  // hex: 0x432ffffffffffffc
  call @func_roundeven64$bitcast_result_to_int(%c4503599627370494_5) : (f64) -> ()
  // CHECK-NEXT: 4841369599423283198
  // hex: 0x432ffffffffffffe
  call @func_roundeven64$bitcast_result_to_int(%c4503599627370495) : (f64) -> ()
  // CHECK-NEXT: 4841369599423283200
  // hex: 0x4330000000000000
  call @func_roundeven64$bitcast_result_to_int(%c4503599627370495_5) : (f64) -> ()
  // CHECK-NEXT: 4841369599423283200
  // hex: 0x10000000000000
  call @func_roundeven64$bitcast_result_to_int(%c4503599627370496) : (f64) -> ()
  // CHECK-NEXT: 4841369599423283201
  // hex: 0x10000000000001
  call @func_roundeven64$bitcast_result_to_int(%c4503599627370497) : (f64) -> ()

  // Check that vector type works
  %cVec = arith.constant dense<[0.5]> : vector<1xf64>
  // CHECK-NEXT: ( 0 )
  call @func_roundeven64$vector(%cVec) : (vector<1xf64>) -> ()
  return
}

func.func @roundeven() {
  call @roundeven32() : () -> ()
  call @roundeven64() : () -> ()
  return
}

// -------------------------------------------------------------------------- //
// Sinh.
// -------------------------------------------------------------------------- //

func.func @sinh_f32(%a : f32) {
  %r = math.sinh %a : f32
  vector.print %r : f32
  return
}

func.func @sinh_4xf32(%a : vector<4xf32>) {
  %r = math.sinh %a : vector<4xf32>
  vector.print %r : vector<4xf32>
  return
}

func.func @sinh_8xf32(%a : vector<8xf32>) {
  %r = math.sinh %a : vector<8xf32>
  vector.print %r : vector<8xf32>
  return
}

func.func @sinh() {
  // CHECK: 1.60192
  %f0 = arith.constant 1.25 : f32
  call @sinh_f32(%f0) : (f32) -> ()

  // CHECK: 0.252612, 0.822317, 1.1752, 1.60192
  %v1 = arith.constant dense<[0.25, 0.75, 1.0, 1.25]> : vector<4xf32>
  call @sinh_4xf32(%v1) : (vector<4xf32>) -> ()

  // CHECK: 0.100167, 0.201336, 0.30452, 0.410752, 0.521095, 0.636654, 0.758584, 0.888106
  %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
  call @sinh_8xf32(%v2) : (vector<8xf32>) -> ()

  // CHECK: -0.100167, -0.201336, -0.30452, -0.410752, -0.521095, -0.636654, -0.758584, -0.888106
  %v3 = arith.constant dense<[-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8]> : vector<8xf32>
  call @sinh_8xf32(%v3) : (vector<8xf32>) -> ()

  // CHECK: nan
  %nan = arith.constant 0x7fc00000 : f32
  call @sinh_f32(%nan) : (f32) -> ()

 return
}

// -------------------------------------------------------------------------- //
// Cosh.
// -------------------------------------------------------------------------- //

func.func @cosh_f32(%a : f32) {
  %r = math.cosh %a : f32
  vector.print %r : f32
  return
}

func.func @cosh_4xf32(%a : vector<4xf32>) {
  %r = math.cosh %a : vector<4xf32>
  vector.print %r : vector<4xf32>
  return
}

func.func @cosh_8xf32(%a : vector<8xf32>) {
  %r = math.cosh %a : vector<8xf32>
  vector.print %r : vector<8xf32>
  return
}

func.func @cosh() {
  // CHECK: 1.88842
  %f0 = arith.constant 1.25 : f32
  call @cosh_f32(%f0) : (f32) -> ()

  // CHECK: 1.03141, 1.29468, 1.54308, 1.88842
  %v1 = arith.constant dense<[0.25, 0.75, 1.0, 1.25]> : vector<4xf32>
  call @cosh_4xf32(%v1) : (vector<4xf32>) -> ()

  // CHECK: 1.005, 1.02007, 1.04534, 1.08107, 1.12763, 1.18547, 1.25517, 1.33743
  %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
  call @cosh_8xf32(%v2) : (vector<8xf32>) -> ()

  // CHECK: 1.005, 1.02007, 1.04534, 1.08107, 1.12763, 1.18547, 1.25517, 1.33743
  %v3 = arith.constant dense<[-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8]> : vector<8xf32>
  call @cosh_8xf32(%v3) : (vector<8xf32>) -> ()

  // CHECK: nan
  %nan = arith.constant 0x7fc00000 : f32
  call @cosh_f32(%nan) : (f32) -> ()

 return
}

// -------------------------------------------------------------------------- //
// Tanh.
// -------------------------------------------------------------------------- //

func.func @tanh_8xf32(%a : vector<8xf32>) {
  %r = math.tanh %a : vector<8xf32>
  vector.print %r : vector<8xf32>
  return
}

func.func @tanh() {
  // CHECK: -1, -0.761594, -0.291313, 0, 0.291313, 0.761594, 1, 1
  %v3 = arith.constant dense<[0xff800000, -1.0, -0.3, 0.0, 0.3, 1.0, 10.0, 0x7f800000]> : vector<8xf32>
  call @tanh_8xf32(%v3) : (vector<8xf32>) -> ()

 return
}

// -------------------------------------------------------------------------- //
// Asinh.
// -------------------------------------------------------------------------- //

func.func @asinh_f32(%a : f32) {
  %r = math.asinh %a : f32
  vector.print %r : f32
  return
}

func.func @asinh_3xf32(%a : vector<3xf32>) {
  %r = math.asinh %a : vector<3xf32>
  vector.print %r : vector<3xf32>
  return
}

func.func @asinh() {
  // CHECK: 0
  %zero = arith.constant 0.0 : f32
  call @asinh_f32(%zero) : (f32) -> ()

  // CHECK: 0.881374
  %cst1 = arith.constant 1.0 : f32
  call @asinh_f32(%cst1) : (f32) -> ()

  // CHECK: -0.881374
  %cst2 = arith.constant -1.0 : f32
  call @asinh_f32(%cst2) : (f32) -> ()

  // CHECK: 1.81845
  %cst3 = arith.constant 3.0 : f32
  call @asinh_f32(%cst3) : (f32) -> ()

  // CHECK: 0.247466, 0.790169, 1.44364
  %vec_x = arith.constant dense<[0.25, 0.875, 2.0]> : vector<3xf32>
  call @asinh_3xf32(%vec_x) : (vector<3xf32>) -> ()

  return
}

// -------------------------------------------------------------------------- //
// Acosh.
// -------------------------------------------------------------------------- //

func.func @acosh_f32(%a : f32) {
  %r = math.acosh %a : f32
  vector.print %r : f32
  return
}

func.func @acosh_3xf32(%a : vector<3xf32>) {
  %r = math.acosh %a : vector<3xf32>
  vector.print %r : vector<3xf32>
  return
}

func.func @acosh() {
  // CHECK: 0
  %zero = arith.constant 1.0 : f32
  call @acosh_f32(%zero) : (f32) -> ()

  // CHECK: 1.31696
  %cst1 = arith.constant 2.0 : f32
  call @acosh_f32(%cst1) : (f32) -> ()

  // CHECK: 2.99322
  %cst2 = arith.constant 10.0 : f32
  call @acosh_f32(%cst2) : (f32) -> ()

  // CHECK: 0.962424, 1.76275, 2.47789
  %vec_x = arith.constant dense<[1.5, 3.0, 6.0]> : vector<3xf32>
  call @acosh_3xf32(%vec_x) : (vector<3xf32>) -> ()

  return
}

// -------------------------------------------------------------------------- //
// Atanh.
// -------------------------------------------------------------------------- //

func.func @atanh_f32(%a : f32) {
  %r = math.atanh %a : f32
  vector.print %r : f32
  return
}

func.func @atanh_3xf32(%a : vector<3xf32>) {
  %r = math.atanh %a : vector<3xf32>
  vector.print %r : vector<3xf32>
  return
}

func.func @atanh() {
  // CHECK: 0
  %zero = arith.constant 0.0 : f32
  call @atanh_f32(%zero) : (f32) -> ()

  // CHECK: 0.549306
  %cst1 = arith.constant 0.5 : f32
  call @atanh_f32(%cst1) : (f32) -> ()

  // CHECK: -0.549306
  %cst2 = arith.constant -0.5 : f32
  call @atanh_f32(%cst2) : (f32) -> ()

  // CHECK: inf
  %cst3 = arith.constant 1.0 : f32
  call @atanh_f32(%cst3) : (f32) -> ()

  // CHECK: 0.255413, 0.394229, 2.99448
  %vec_x = arith.constant dense<[0.25, 0.375, 0.995]> : vector<3xf32>
  call @atanh_3xf32(%vec_x) : (vector<3xf32>) -> ()

  return
}

// -------------------------------------------------------------------------- //
// Rsqrt.
// -------------------------------------------------------------------------- //

func.func @rsqrt_f32(%a : f32) {
  %r = math.rsqrt %a : f32
  vector.print %r : f32
  return
}

func.func @rsqrt_3xf32(%a : vector<3xf32>) {
  %r = math.rsqrt %a : vector<3xf32>
  vector.print %r : vector<3xf32>
  return
}

func.func @rsqrt() {
  // CHECK: 1
  %zero = arith.constant 1.0 : f32
  call @rsqrt_f32(%zero) : (f32) -> ()

  // CHECK: 0.707107
  %cst1 = arith.constant 2.0 : f32
  call @rsqrt_f32(%cst1) : (f32) -> ()

  // CHECK: inf
  %cst2 = arith.constant 0.0 : f32
  call @rsqrt_f32(%cst2) : (f32) -> ()

  // CHECK: nan
  %cst3 = arith.constant -1.0 : f32
  call @rsqrt_f32(%cst3) : (f32) -> ()

  // CHECK: 0.5, 1.41421, 0.57735
  %vec_x = arith.constant dense<[4.0, 0.5, 3.0]> : vector<3xf32>
  call @rsqrt_3xf32(%vec_x) : (vector<3xf32>) -> ()

  return
}

func.func @main() {
  call @exp2f() : () -> ()
  call @roundf() : () -> ()
  call @powf() : () -> ()
  call @roundeven() : () -> ()
  call @sinh() : () -> ()
  call @cosh() : () -> ()
  call @tanh() : () -> ()
  call @asinh() : () -> ()
  call @acosh() : () -> ()
  call @atanh() : () -> ()
  call @rsqrt() : () -> ()
  return
}