1. 支持所有wat基本类型

2. 支持heart例子

heart.wa

+// 版权 @2021 凹语言 作者。保留所有权利。
+
+package main
+
+fn main() {
+	a := 0.0
+	for y := 1.5; y > -1.5; y = y - 0.1 {
+		for x := -1.5; x < 1.5; x = x + 0.05 {
+			a = x*x + y*y - 1.0
+			if a*a*a < x*x*y*y*y {
+				print('@')
+			} else {
+				print(' ')
+			}
+		}
+		println()
+	}
+}

internal/backends/compiler_wat/compile_func.go

@@ -46,22 +46,29 @@ func (g *functionGenerator) getValue(i ssa.Value) wir.Value {
 		switch t := v.Type().(type) {
 		case *types.Basic:
 			switch t.Kind() {
+
 			case types.Bool:
 				logger.Fatalf("Todo:%T", t)
 
 			case types.Int:
 				val, _ := constant.Int64Val(v.Value)
-				return wir.NewConstI32(int32(val))
+				return wir.NewConst(wir.I32{}, strconv.Itoa(int(val)))
 
 			case types.Int32:
 				val, _ := constant.Int64Val(v.Value)
-				return wir.NewConstI32(int32(val))
+				if t.Name() == "rune" {
+					return wir.NewConst(wir.RUNE{}, strconv.Itoa(int(val)))
+				} else {
+					return wir.NewConst(wir.I32{}, strconv.Itoa(int(val)))
+				}
 
 			case types.Float32:
-				logger.Fatalf("Todo:%T", t)
+				val, _ := constant.Float64Val(v.Value)
+				return wir.NewConst(wir.F32{}, strconv.FormatFloat(val, 'f', -1, 32))
 
 			case types.Float64:
-				logger.Fatalf("Todo:%T", t)
+				val, _ := constant.Float64Val(v.Value)
+				return wir.NewConst(wir.F64{}, strconv.FormatFloat(val, 'f', -1, 64))
 
 			case types.String, types.UntypedString:
 				logger.Fatalf("Todo:%T", t)
@@ -103,11 +110,11 @@ func (g *functionGenerator) genFunction(f *ssa.Function) *wat.Function {
 		g.locals_map[i] = pa
 	}
 
-	g.var_block_selector = wir.NewVar("$block_selector", wir.ValueKindLocal, wir.Int32{})
+	g.var_block_selector = wir.NewVar("$block_selector", wir.ValueKindLocal, wir.I32{})
 	g.registers = append(g.registers, g.var_block_selector)
 	wir_fn.Insts = append(wir_fn.Insts, g.var_block_selector.EmitInit()...)
 
-	g.var_current_block = wir.NewVar("$current_block", wir.ValueKindLocal, wir.Int32{})
+	g.var_current_block = wir.NewVar("$current_block", wir.ValueKindLocal, wir.I32{})
 	g.registers = append(g.registers, g.var_current_block)
 	wir_fn.Insts = append(wir_fn.Insts, g.var_current_block.EmitInit()...)
 
@@ -173,7 +180,7 @@ func (g *functionGenerator) genBlock(block *ssa.BasicBlock) []wat.Inst {
 	for _, inst := range block.Instrs {
 		if _, ok := inst.(*ssa.Phi); !ok {
 			if !cur_block_assigned {
-				b = append(b, wir.EmitAssginValue(g.var_current_block, wir.NewConstI32(int32(block.Index)))...)
+				b = append(b, wir.EmitAssginValue(g.var_current_block, wir.NewConst(wir.I32{}, strconv.Itoa(block.Index)))...)
 				cur_block_assigned = true
 			}
 		}
@@ -341,17 +348,21 @@ func (g *functionGenerator) genBuiltin(call *ssa.CallCommon) ([]wat.Inst, wir.Va
 		for _, arg := range call.Args {
 			arg := g.getValue(arg)
 			switch arg.Type().(type) {
-			case wir.Int32:
+			case wir.I32:
 				insts = append(insts, arg.EmitGet()...)
 				insts = append(insts, wat.NewInstCall("$print_i32"))
 
+			case wir.RUNE:
+				insts = append(insts, arg.EmitGet()...)
+				insts = append(insts, wat.NewInstCall("$print_rune"))
+
 			default:
 				logger.Fatalf("Todo: print(%T)", arg.Type())
 			}
 		}
 
 		if call.Value.Name() == "println" {
-			insts = append(insts, wir.NewConstI32('\n').EmitGet()...)
+			insts = append(insts, wir.NewConst(wir.I32{}, strconv.Itoa('\n')).EmitGet()...)
 			insts = append(insts, wat.NewInstCall("$print_rune"))
 		}
 
@@ -364,7 +375,7 @@ func (g *functionGenerator) genBuiltin(call *ssa.CallCommon) ([]wat.Inst, wir.Va
 func (g *functionGenerator) genPhiIter(preds []int, values []wir.Value) []wat.Inst {
 	var insts []wat.Inst
 
-	cond, _ := wir.EmitBinOp(g.var_current_block, wir.NewConstI32(int32(preds[0])), wat.OpCodeEql)
+	cond, _ := wir.EmitBinOp(g.var_current_block, wir.NewConst(wir.I32{}, strconv.Itoa(preds[0])), wat.OpCodeEql)
 	insts = append(insts, cond...)
 
 	trueInsts := values[0].EmitGet()
@@ -408,7 +419,7 @@ func (g *functionGenerator) genReturn(inst *ssa.Return) []wat.Inst {
 
 func (g *functionGenerator) genIf(inst *ssa.If) []wat.Inst {
 	cond := g.getValue(inst.Cond)
-	if !cond.Type().Equal(wir.Int32{}) {
+	if !cond.Type().Equal(wir.I32{}) {
 		logger.Fatal("cond.type() != i32")
 	}
 
@@ -428,7 +439,7 @@ func (g *functionGenerator) genJumpID(cur, dest int) []wat.Inst {
 	var insts []wat.Inst
 
 	if cur >= dest {
-		insts = wir.EmitAssginValue(g.var_block_selector, wir.NewConstI32(int32(dest)))
+		insts = wir.EmitAssginValue(g.var_block_selector, wir.NewConst(wir.I32{}, strconv.Itoa(dest)))
 		insts = append(insts, wat.NewInstBr("$BlockDisp"))
 	} else {
 		insts = append(insts, wat.NewInstBr("$Block_"+strconv.Itoa(dest-1)))

internal/backends/compiler_wat/wir/util.go

@@ -10,37 +10,34 @@ func ToWType(from types.Type) ValueType {
 	switch t := from.(type) {
 	case *types.Basic:
 		switch t.Kind() {
-		case types.Bool:
-			return Int32{}
+		case types.Bool, types.Int, types.Int32, types.UntypedInt:
+			return I32{}
 
-		case types.Int8, types.UntypedBool:
-			logger.Fatalf("ToWType Todo:%T", t)
-
-		case types.Uint8:
-			logger.Fatalf("ToWType Todo:%T", t)
+		case types.Uint32:
+			return U32{}
 
-		case types.Int16:
-			logger.Fatalf("ToWType Todo:%T", t)
+		case types.Int64:
+			return I64{}
 
-		case types.Uint16:
-			logger.Fatalf("ToWType Todo:%T", t)
+		case types.Uint64:
+			return U64{}
 
-		case types.Int, types.Int32, types.UntypedInt:
-			return Int32{}
+		case types.Float32, types.UntypedFloat:
+			return F32{}
 
-		case types.Uint, types.Uint32:
-			logger.Fatalf("ToWType Todo:%T", t)
+		case types.Float64:
+			return F64{}
 
-		case types.Int64:
+		case types.Int8, types.UntypedBool:
 			logger.Fatalf("ToWType Todo:%T", t)
 
-		case types.Uint64:
+		case types.Uint8:
 			logger.Fatalf("ToWType Todo:%T", t)
 
-		case types.Float32, types.UntypedFloat:
+		case types.Int16:
 			logger.Fatalf("ToWType Todo:%T", t)
 
-		case types.Float64:
+		case types.Uint16:
 			logger.Fatalf("ToWType Todo:%T", t)
 
 		case types.String:

internal/backends/compiler_wat/wir/value_const.go

 package wir
 
 import (
-	"strconv"
-
 	"github.com/wa-lang/wa/internal/backends/compiler_wat/wir/wat"
 	"github.com/wa-lang/wa/internal/logger"
 )
@@ -24,27 +22,28 @@ func (c *ConstZero) Type() wtypes.ValueType { return wtypes.Void{} }
 func (c *ConstZero) Raw() []Value           { return append([]Value(nil), c) }
 //*/
 
-func NewConst(t ValueType, v interface{}) Const {
+func NewConst(t ValueType, lit string) Const {
 	switch t.(type) {
-	case Int32:
-		if v == nil {
-			return NewConstI32(0)
-		}
-
-		if c, ok := v.(int); ok {
-			return NewConstI32(int32(c))
-		}
-		logger.Fatal("Todo")
+	case RUNE:
+		return &constRune{aConst: aConst{typ: t, lit: lit}}
 
-	case Int64:
-		if v == nil {
-			return NewConstI64(0)
-		}
+	case I32:
+		return &constI32{aConst: aConst{typ: t, lit: lit}}
 
-		if c, ok := v.(int); ok {
-			return NewConstI64(int64(c))
-		}
-		logger.Fatal("Todo")
+	case U32:
+		return &constU32{aConst: aConst{typ: t, lit: lit}}
+
+	case I64:
+		return &constI64{aConst: aConst{typ: t, lit: lit}}
+
+	case U64:
+		return &constU64{aConst: aConst{typ: t, lit: lit}}
+
+	case F32:
+		return &constF32{aConst: aConst{typ: t, lit: lit}}
+
+	case F64:
+		return &constF64{aConst: aConst{typ: t, lit: lit}}
 
 	default:
 		logger.Fatal("Todo")
@@ -54,39 +53,80 @@ func NewConst(t ValueType, v interface{}) Const {
 }
 
 /**************************************
-ConstInt32:
+aConst:
 **************************************/
-type ConstI32 struct {
-	x int32
+type aConst struct {
+	typ ValueType
+	lit string
 }
 
-func NewConstI32(x int32) *ConstI32         { return &ConstI32{x: x} }
-func (c *ConstI32) Name() string            { return strconv.FormatInt(int64(c.x), 10) }
-func (c *ConstI32) Kind() ValueKind         { return ValueKindConst }
-func (c *ConstI32) Type() ValueType         { return Int32{} }
-func (c *ConstI32) raw() []wat.Value        { logger.Fatal("Todo"); return nil }
-func (c *ConstI32) EmitInit() []wat.Inst    { logger.Fatal("不可0值化常数"); return nil }
-func (c *ConstI32) EmitSet() []wat.Inst     { logger.Fatal("不可Pop至常数"); return nil }
-func (c *ConstI32) EmitRelease() []wat.Inst { logger.Fatal("不可清除常数"); return nil }
-func (c *ConstI32) EmitGet() []wat.Inst {
-	return []wat.Inst{wat.NewInstConst(wat.I32{}, strconv.Itoa(int(int32(c.x))))}
+func (c *aConst) Name() string            { return c.lit }
+func (c *aConst) Kind() ValueKind         { return ValueKindConst }
+func (c *aConst) Type() ValueType         { return c.typ }
+func (c *aConst) raw() []wat.Value        { logger.Fatal("Todo"); return nil }
+func (c *aConst) EmitInit() []wat.Inst    { logger.Fatal("不可0值化常数"); return nil }
+func (c *aConst) EmitSet() []wat.Inst     { logger.Fatal("不可Pop至常数"); return nil }
+func (c *aConst) EmitRelease() []wat.Inst { logger.Fatal("不可清除常数"); return nil }
+
+/**************************************
+constRune:
+**************************************/
+type constRune struct {
+	aConst
 }
 
+func (c *constRune) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.I32{}, c.lit)} }
+
 /**************************************
-ConstInt64:
+constI32:
 **************************************/
-type ConstI64 struct {
-	x int64
+type constI32 struct {
+	aConst
 }
 
-func NewConstI64(x int64) *ConstI64         { return &ConstI64{x: x} }
-func (c *ConstI64) Name() string            { return strconv.FormatInt(c.x, 10) }
-func (c *ConstI64) Kind() ValueKind         { return ValueKindConst }
-func (c *ConstI64) Type() ValueType         { return Int64{} }
-func (c *ConstI64) raw() []wat.Value        { logger.Fatal("Todo"); return nil }
-func (c *ConstI64) EmitInit() []wat.Inst    { logger.Fatal("不可0值化常数"); return nil }
-func (c *ConstI64) EmitSet() []wat.Inst     { logger.Fatal("不可Pop至常数"); return nil }
-func (c *ConstI64) EmitRelease() []wat.Inst { logger.Fatal("不可清除常数"); return nil }
-func (c *ConstI64) EmitGet() []wat.Inst {
-	return []wat.Inst{wat.NewInstConst(wat.I64{}, strconv.Itoa(int(c.x)))}
+func (c *constI32) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.I32{}, c.lit)} }
+
+/**************************************
+constU32:
+**************************************/
+type constU32 struct {
+	aConst
 }
+
+func (c *constU32) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.U32{}, c.lit)} }
+
+/**************************************
+constI64:
+**************************************/
+type constI64 struct {
+	aConst
+}
+
+func (c *constI64) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.I64{}, c.lit)} }
+
+/**************************************
+constU64:
+**************************************/
+type constU64 struct {
+	aConst
+}
+
+func (c *constU64) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.U64{}, c.lit)} }
+
+/**************************************
+constF32:
+**************************************/
+type constF32 struct {
+	aConst
+}
+
+func (c *constF32) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.F32{}, c.lit)} }
+
+/**************************************
+constF64:
+**************************************/
+type constF64 struct {
+	aConst
+}
+
+func (c *constF64) EmitGet() []wat.Inst { return []wat.Inst{wat.NewInstConst(wat.F64{}, c.lit)} }

internal/backends/compiler_wat/wir/value_type.go

@@ -8,47 +8,74 @@ import (
 /**************************************
 Void:
 **************************************/
-type Void struct {
-}
+type Void struct{}
 
-func (t Void) byteSize() int        { return 0 }
-func (t Void) Raw() []wat.ValueType { return []wat.ValueType{} }
-func (t Void) Equal(u ValueType) bool {
-	if _, ok := u.(Void); ok {
-		return true
-	}
-	return false
-}
+func (t Void) byteSize() int          { return 0 }
+func (t Void) Raw() []wat.ValueType   { return []wat.ValueType{} }
+func (t Void) Equal(u ValueType) bool { _, ok := u.(Void); return ok }
 
 /**************************************
-Int32:
+RUNE:
 **************************************/
-type Int32 struct {
-}
+type RUNE struct{}
 
-func (t Int32) byteSize() int        { return 4 }
-func (t Int32) Raw() []wat.ValueType { return []wat.ValueType{wat.I32{}} }
-func (t Int32) Equal(u ValueType) bool {
-	if _, ok := u.(Int32); ok {
-		return true
-	}
-	return false
-}
+func (t RUNE) byteSize() int          { return 4 }
+func (t RUNE) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
+func (t RUNE) Equal(u ValueType) bool { _, ok := u.(RUNE); return ok }
 
 /**************************************
-Int64:
+I32:
 **************************************/
-type Int64 struct {
-}
+type I32 struct{}
 
-func (t Int64) byteSize() int        { return 8 }
-func (t Int64) Raw() []wat.ValueType { return []wat.ValueType{wat.I64{}} }
-func (t Int64) Equal(u ValueType) bool {
-	if _, ok := u.(Int64); ok {
-		return true
-	}
-	return false
-}
+func (t I32) byteSize() int          { return 4 }
+func (t I32) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
+func (t I32) Equal(u ValueType) bool { _, ok := u.(I32); return ok }
+
+/**************************************
+U32:
+**************************************/
+type U32 struct{}
+
+func (t U32) byteSize() int          { return 4 }
+func (t U32) Raw() []wat.ValueType   { return []wat.ValueType{wat.U32{}} }
+func (t U32) Equal(u ValueType) bool { _, ok := u.(U32); return ok }
+
+/**************************************
+I64:
+**************************************/
+type I64 struct{}
+
+func (t I64) byteSize() int          { return 8 }
+func (t I64) Raw() []wat.ValueType   { return []wat.ValueType{wat.I64{}} }
+func (t I64) Equal(u ValueType) bool { _, ok := u.(I64); return ok }
+
+/**************************************
+Uint64:
+**************************************/
+type U64 struct{}
+
+func (t U64) byteSize() int          { return 8 }
+func (t U64) Raw() []wat.ValueType   { return []wat.ValueType{wat.U64{}} }
+func (t U64) Equal(u ValueType) bool { _, ok := u.(U64); return ok }
+
+/**************************************
+F32:
+**************************************/
+type F32 struct{}
+
+func (t F32) byteSize() int          { return 4 }
+func (t F32) Raw() []wat.ValueType   { return []wat.ValueType{wat.F32{}} }
+func (t F32) Equal(u ValueType) bool { _, ok := u.(F32); return ok }
+
+/**************************************
+F64:
+**************************************/
+type F64 struct{}
+
+func (t F64) byteSize() int          { return 8 }
+func (t F64) Raw() []wat.ValueType   { return []wat.ValueType{wat.F64{}} }
+func (t F64) Equal(u ValueType) bool { _, ok := u.(F64); return ok }
 
 /**************************************
 Pointer:

internal/backends/compiler_wat/wir/value_var.go

@@ -7,8 +7,23 @@ import (
 
 func NewVar(name string, kind ValueKind, typ ValueType) Value {
 	switch typ.(type) {
-	case Int32:
-		return NewVarI32(name, kind)
+	case I32:
+		return newVarI32(name, kind)
+
+	case U32:
+		return newVarU32(name, kind)
+
+	case I64:
+		return newVarI64(name, kind)
+
+	case U64:
+		return newVarU64(name, kind)
+
+	case F32:
+		return newVarF32(name, kind)
+
+	case F64:
+		return newVarF64(name, kind)
 
 	default:
 		logger.Fatalf("Todo: %T", typ)
@@ -48,22 +63,112 @@ func (v *aVar) rawSet(name string) wat.Inst {
 }
 
 /**************************************
-VarI32:
+varI32:
 **************************************/
-type VarI32 struct {
+type varI32 struct {
 	aVar
 }
 
-func NewVarI32(name string, kind ValueKind) *VarI32 {
-	return &VarI32{aVar: aVar{name: name, kind: kind, typ: Int32{}}}
+func newVarI32(name string, kind ValueKind) *varI32 {
+	return &varI32{aVar: aVar{name: name, kind: kind, typ: I32{}}}
 }
-func (v *VarI32) raw() []wat.Value { return []wat.Value{wat.NewVarI32(v.name)} }
-func (v *VarI32) EmitInit() []wat.Inst {
+func (v *varI32) raw() []wat.Value { return []wat.Value{wat.NewVarI32(v.name)} }
+func (v *varI32) EmitInit() []wat.Inst {
 	return []wat.Inst{wat.NewInstConst(wat.I32{}, "0"), v.rawSet(v.name)}
 }
-func (v *VarI32) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
-func (v *VarI32) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
-func (v *VarI32) EmitRelease() []wat.Inst { return nil }
+func (v *varI32) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varI32) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varI32) EmitRelease() []wat.Inst { return nil }
+
+/**************************************
+varU32:
+**************************************/
+type varU32 struct {
+	aVar
+}
+
+func newVarU32(name string, kind ValueKind) *varU32 {
+	return &varU32{aVar: aVar{name: name, kind: kind, typ: U32{}}}
+}
+func (v *varU32) raw() []wat.Value { return []wat.Value{wat.NewVarU32(v.name)} }
+func (v *varU32) EmitInit() []wat.Inst {
+	return []wat.Inst{wat.NewInstConst(wat.U32{}, "0"), v.rawSet(v.name)}
+}
+func (v *varU32) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varU32) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varU32) EmitRelease() []wat.Inst { return nil }
+
+/**************************************
+varI64:
+**************************************/
+type varI64 struct {
+	aVar
+}
+
+func newVarI64(name string, kind ValueKind) *varI64 {
+	return &varI64{aVar: aVar{name: name, kind: kind, typ: I64{}}}
+}
+func (v *varI64) raw() []wat.Value { return []wat.Value{wat.NewVarI64(v.name)} }
+func (v *varI64) EmitInit() []wat.Inst {
+	return []wat.Inst{wat.NewInstConst(wat.I64{}, "0"), v.rawSet(v.name)}
+}
+func (v *varI64) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varI64) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varI64) EmitRelease() []wat.Inst { return nil }
+
+/**************************************
+varU64:
+**************************************/
+type varU64 struct {
+	aVar
+}
+
+func newVarU64(name string, kind ValueKind) *varU64 {
+	return &varU64{aVar: aVar{name: name, kind: kind, typ: U64{}}}
+}
+func (v *varU64) raw() []wat.Value { return []wat.Value{wat.NewVarU64(v.name)} }
+func (v *varU64) EmitInit() []wat.Inst {
+	return []wat.Inst{wat.NewInstConst(wat.U64{}, "0"), v.rawSet(v.name)}
+}
+func (v *varU64) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varU64) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varU64) EmitRelease() []wat.Inst { return nil }
+
+/**************************************
+varF32:
+**************************************/
+type varF32 struct {
+	aVar
+}
+
+func newVarF32(name string, kind ValueKind) *varF32 {
+	return &varF32{aVar: aVar{name: name, kind: kind, typ: F32{}}}
+}
+func (v *varF32) raw() []wat.Value { return []wat.Value{wat.NewVarF32(v.name)} }
+func (v *varF32) EmitInit() []wat.Inst {
+	return []wat.Inst{wat.NewInstConst(wat.F32{}, "0"), v.rawSet(v.name)}
+}
+func (v *varF32) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varF32) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varF32) EmitRelease() []wat.Inst { return nil }
+
+/**************************************
+varF64:
+**************************************/
+type varF64 struct {
+	aVar
+}
+
+func newVarF64(name string, kind ValueKind) *varF64 {
+	return &varF64{aVar: aVar{name: name, kind: kind, typ: F64{}}}
+}
+func (v *varF64) raw() []wat.Value { return []wat.Value{wat.NewVarF64(v.name)} }
+func (v *varF64) EmitInit() []wat.Inst {
+	return []wat.Inst{wat.NewInstConst(wat.F64{}, "0"), v.rawSet(v.name)}
+}
+func (v *varF64) EmitGet() []wat.Inst     { return []wat.Inst{v.rawGet(v.name)} }
+func (v *varF64) EmitSet() []wat.Inst     { return []wat.Inst{v.rawSet(v.name)} }
+func (v *varF64) EmitRelease() []wat.Inst { return nil }
 
 /**************************************
 VarPointer:

internal/backends/compiler_wat/wir/wat/instruction.go

@@ -97,6 +97,22 @@ func (i *InstDiv) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.div_s"
+
+	case U32:
+		return indent + "i32.div_u"
+
+	case I64:
+		return indent + "i64.div_s"
+
+	case U64:
+		return indent + "i64.div_u"
+
+	case F32:
+		return indent + "f32.div"
+
+	case F64:
+		return indent + "f64.div"
+
 	}
 	logger.Fatal("Todo")
 	return ""
@@ -115,6 +131,15 @@ func (i *InstRem) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.rem_s"
+
+	case U32:
+		return indent + "i32.rem_u"
+
+	case I64:
+		return indent + "i64.rem_s"
+
+	case U64:
+		return indent + "i64.rem_u"
 	}
 	logger.Fatal("Todo")
 	return ""
@@ -155,6 +180,21 @@ func (i *InstLt) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.lt_s"
+
+	case U32:
+		return indent + "i32.lt_u"
+
+	case I64:
+		return indent + "i64.lt_s"
+
+	case U64:
+		return indent + "i64.lt_u"
+
+	case F32:
+		return indent + "f32.lt"
+
+	case F64:
+		return indent + "f64.lt"
 	}
 	logger.Fatal("Todo")
 	return ""
@@ -173,6 +213,21 @@ func (i *InstGt) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.gt_s"
+
+	case U32:
+		return indent + "i32.gt_u"
+
+	case I64:
+		return indent + "i64.gt_s"
+
+	case U64:
+		return indent + "i64.gt_u"
+
+	case F32:
+		return indent + "f32.gt"
+
+	case F64:
+		return indent + "f64.gt"
 	}
 	logger.Fatal("Todo")
 	return ""
@@ -191,6 +246,21 @@ func (i *InstLe) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.le_s"
+
+	case U32:
+		return indent + "i32.le_u"
+
+	case I64:
+		return indent + "i64.le_s"
+
+	case U64:
+		return indent + "i64.le_u"
+
+	case F32:
+		return indent + "f32.le"
+
+	case F64:
+		return indent + "f64.le"
 	}
 	logger.Fatal("Todo")
 	return ""
@@ -209,6 +279,21 @@ func (i *InstGe) Format(indent string) string {
 	switch i.typ.(type) {
 	case I32:
 		return indent + "i32.ge_s"
+
+	case U32:
+		return indent + "i32.ge_u"
+
+	case I64:
+		return indent + "i64.ge_s"
+
+	case U64:
+		return indent + "i64.ge_u"
+
+	case F32:
+		return indent + "f32.ge"
+
+	case F64:
+		return indent + "f64.ge"
 	}
 	logger.Fatal("Todo")
 	return ""

internal/backends/compiler_wat/wir/wat/value.go

@@ -8,28 +8,54 @@ I32:
 type I32 struct {
 }
 
-func (t I32) Name() string { return "i32" }
-func (t I32) Equal(u ValueType) bool {
-	if _, ok := u.(I32); ok {
-		return true
-	}
-	return false
+func (t I32) Name() string           { return "i32" }
+func (t I32) Equal(u ValueType) bool { _, ok := u.(I32); return ok }
+
+/**************************************
+U32:
+**************************************/
+type U32 struct {
 }
 
+func (t U32) Name() string           { return "i32" }
+func (t U32) Equal(u ValueType) bool { _, ok := u.(U32); return ok }
+
 /**************************************
 I64:
 **************************************/
 type I64 struct {
 }
 
-func (t I64) Name() string { return "i64" }
-func (t I64) Equal(u ValueType) bool {
-	if _, ok := u.(I64); ok {
-		return true
-	}
-	return false
+func (t I64) Name() string           { return "i64" }
+func (t I64) Equal(u ValueType) bool { _, ok := u.(I64); return ok }
+
+/**************************************
+U64:
+**************************************/
+type U64 struct {
+}
+
+func (t U64) Name() string           { return "i64" }
+func (t U64) Equal(u ValueType) bool { _, ok := u.(U64); return ok }
+
+/**************************************
+F32:
+**************************************/
+type F32 struct {
 }
 
+func (t F32) Name() string           { return "f32" }
+func (t F32) Equal(u ValueType) bool { _, ok := u.(F32); return ok }
+
+/**************************************
+F64:
+**************************************/
+type F64 struct {
+}
+
+func (t F64) Name() string           { return "f64" }
+func (t F64) Equal(u ValueType) bool { _, ok := u.(F64); return ok }
+
 /**************************************
 aVar:
 **************************************/
@@ -51,3 +77,58 @@ type VarI32 struct {
 func NewVarI32(name string) *VarI32 {
 	return &VarI32{aVar: aVar{typ: I32{}, name: name}}
 }
+
+/**************************************
+VarU32:
+**************************************/
+type VarU32 struct {
+	aVar
+}
+
+func NewVarU32(name string) *VarU32 {
+	return &VarU32{aVar: aVar{typ: U32{}, name: name}}
+}
+
+/**************************************
+VarI64:
+**************************************/
+type VarI64 struct {
+	aVar
+}
+
+func NewVarI64(name string) *VarI64 {
+	return &VarI64{aVar: aVar{typ: I64{}, name: name}}
+}
+
+/**************************************
+VarU64:
+**************************************/
+type VarU64 struct {
+	aVar
+}
+
+func NewVarU64(name string) *VarU64 {
+	return &VarU64{aVar: aVar{typ: U64{}, name: name}}
+}
+
+/**************************************
+VarF32:
+**************************************/
+type VarF32 struct {
+	aVar
+}
+
+func NewVarF32(name string) *VarF32 {
+	return &VarF32{aVar: aVar{typ: F32{}, name: name}}
+}
+
+/**************************************
+VarF64:
+**************************************/
+type VarF64 struct {
+	aVar
+}
+
+func NewVarF64(name string) *VarF64 {
+	return &VarF64{aVar: aVar{typ: F64{}, name: name}}
+}