#ifndef HANDLE_TF_REF_TYPE
#define HANDLE_TF_REF_TYPE(class, enumerant, name) \
  HANDLE_TF_TYPE(class, enumerant, name)
#endif
HANDLE_TF_REF_TYPE(FloatRef, FLOAT_REF, "f32ref")
HANDLE_TF_REF_TYPE(DoubleRef, DOUBLE_REF, "f64ref")
HANDLE_TF_REF_TYPE(Uint4Ref, UINT4_REF, "uint4ref")
HANDLE_TF_REF_TYPE(Int4Ref, INT4_REF, "int4ref")
HANDLE_TF_REF_TYPE(Uint8Ref, UINT8_REF, "uint8ref")

// Reference types

// Float reference types
def TF_Float16Ref : TF_TensorFlowType<"HalfRef", "f16ref">;
def TF_Float32Ref : TF_TensorFlowType<"FloatRef", "f32ref">;
def TF_Float64Ref : TF_TensorFlowType<"DoubleRef", "f64ref">;
def TF_Bfloat16Ref : TF_TensorFlowType<"Bfloat16Ref", "bf16ref">;
def TF_Float8E4M3FNRef : TF_TensorFlowType<"Float8E4M3FNRef", "float8e4m3fnref">;

	"I64LtS",
	"I64LtU",
	"I64GtS",
	"I64GtU",
	"I64LeS",
	"I64LeU",
	"I64GeS",
	"I64GeU",
	"F32Eq",
	"F32Ne",
	"F32Lt",
	"F32Gt",
	"F32Le",
	"F32Ge",
	"F64Eq",
	"F64Ne",
	"F64Lt",
	"F64Gt",
	"F64Le",
	"F64Ge",
	"I32Clz",
	"I32Ctz",
	"I32Popcnt",
	"I32Add",
	"I32Sub",
	"I32Mul",
	"I32DivS",
	"I32DivU",
	"I32RemS",
	"I32RemU",
	"I32And",
	"I32Or",
	"I32Xor",

func.func @testRealDivWithRef(%arg0: tensor<f64>, %arg1: tensor<!tf_type.f64ref>) -> tensor<f64> {
  // CHECK: tf.RealDivOp
  %0 = "tf.RealDivOp"(%arg0, %arg1) : (tensor<f64>, tensor<!tf_type.f64ref>) -> tensor<f64>
  func.return %0 : tensor<f64>
}

// CHECK-LABEL: @testDivNoNanWithRef
func.func @testDivNoNanWithRef(%arg0: tensor<f32>, %arg1: tensor<!tf_type.f32ref>) -> tensor<f32> {
  // CHECK: tf.DivNoNanOp

		{name: "F64Eq", asm: "F64Eq", argLength: 2, reg: fp64_21gp, typ: "Bool"}, // arg0 == arg1
		{name: "F64Ne", asm: "F64Ne", argLength: 2, reg: fp64_21gp, typ: "Bool"}, // arg0 != arg1
		{name: "F64Lt", asm: "F64Lt", argLength: 2, reg: fp64_21gp, typ: "Bool"}, // arg0 < arg1
		{name: "F64Gt", asm: "F64Gt", argLength: 2, reg: fp64_21gp, typ: "Bool"}, // arg0 > arg1

package test

import (
	"testing"
)

var boolres bool

var i64res int64

func BenchmarkDivconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) / 7
	}
}

func BenchmarkModconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) % 7
	}
}

func BenchmarkDivisiblePow2constI64(b *testing.B) {
	for i := 0; i < b.N; i++ {

  %val0 = "tf.VariableV2"() {_class = ["loc:@v"], container = "", device = "", shape = #tf_type.shape<96>, shared_name = ""} : () -> tensor<96x!tf_type.f32ref>
  %val1 = "tf.Identity"(%val0) : (tensor<96x!tf_type.f32ref>) -> tensor<96xf32>
  %val2 = "tf.Identity"(%val0) : (tensor<96x!tf_type.f32ref>) -> tensor<96xf32>
  func.return
}

// -----

// Test case: No follow-up ReadVariable case.

func.func @f() {

// Check that if result is a ref type, all operands need to be ref too.
func.func @invalid_merge(%arg0: tensor<4x!tf_type.f32ref>, %arg1: tensor<4xf32>) -> tensor<4x!tf_type.f32ref> {
  %result = tf_executor.graph {
    %value, %idx, %ctlMerge = "tf_executor.Merge"(%arg0, %arg1) : (tensor<4x!tf_type.f32ref>, tensor<4xf32>) -> (tensor<4x!tf_type.f32ref>, tensor<i32>, !tf_executor.control)

      %outputs_0, %control_1 = tf_executor.island wraps "tf.Identity"(%outputs) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<!tf_type.f32ref>) -> tensor<*xf32>
      tf_executor.fetch %outputs_0 : tensor<*xf32>
    }
    func.return %0 : tensor<*xf32>
  }

		I64Const $-1
		I64Eq
		If
			I64Const $-0x8000000000000000
			Return
		End
	End
	Get R0
	Get R1
	I64DivS
	Return

TEXT runtime·wasmTruncS(SB), NOSPLIT, $0-0
	Get R0
	Get R0
	F64Ne // NaN
	If
		I64Const $0x8000000000000000
		Return
	End

	Get R0
	F64Const $0x7ffffffffffffc00p0 // Maximum truncated representation of 0x7fffffffffffffff
	F64Gt
	If
		I64Const $0x8000000000000000