Repository: tetratelabs/wazero
Pull request #87 (2021-12-23 08:31:56)

ir: rename sign{ful,less} -> signed,unsigned
per https://github.com/tetratelabs/wazero/pull/86#discussion_r774400193


Patch:
diff --git a/wasm/jit/jit_amd64.go b/wasm/jit/jit_amd64.go
index e2ba42ee..341ae1b1 100644
--- a/wasm/jit/jit_amd64.go
+++ b/wasm/jit/jit_amd64.go
@@ -255,7 +255,7 @@ func (b *amd64Builder) newCompiledWasmFunction(code []byte) *compiledWasmFunctio
 func (b *amd64Builder) pushFunctionInputs() {
 	for _, t := range b.f.Signature.InputTypes {
 		loc := b.locationStack.pushValueOnStack()
-		loc.setValueType(wazeroir.WasmValueTypeToSignless(t))
+		loc.setValueType(wazeroir.WasmValueTypeToUnsignedType(t))
 	}
 }
 
@@ -463,7 +463,7 @@ func (b *amd64Builder) handleGlobalGet(o *wazeroir.OperationGlobalGet) error {
 
 	// Record that the retrieved global value on the top of the stack is now in a register.
 	loc := b.locationStack.pushValueOnRegister(valueReg)
-	loc.setValueType(wazeroir.WasmValueTypeToSignless(wasmType))
+	loc.setValueType(wazeroir.WasmValueTypeToUnsignedType(wasmType))
 	return nil
 }
 
@@ -911,18 +911,18 @@ func (b *amd64Builder) handleAdd(o *wazeroir.OperationAdd) error {
 	var instruction obj.As
 	var tp generalPurposeRegisterType
 	switch o.Type {
-	case wazeroir.SignLessTypeI32:
+	case wazeroir.UnsignedTypeI32:
 		instruction = x86.AADDL
 		tp = generalPurposeRegisterTypeInt
 		panic("add tests!")
-	case wazeroir.SignLessTypeI64:
+	case wazeroir.UnsignedTypeI64:
 		instruction = x86.AADDQ
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignLessTypeF32:
+	case wazeroir.UnsignedTypeF32:
 		instruction = x86.AADDSS
 		tp = generalPurposeRegisterTypeFloat
 		panic("add tests!")
-	case wazeroir.SignLessTypeF64:
+	case wazeroir.UnsignedTypeF64:
 		instruction = x86.AADDSD
 		tp = generalPurposeRegisterTypeFloat
 		panic("add tests!")
@@ -972,18 +972,18 @@ func (b *amd64Builder) handleSub(o *wazeroir.OperationSub) error {
 	var instruction obj.As
 	var tp generalPurposeRegisterType
 	switch o.Type {
-	case wazeroir.SignLessTypeI32:
+	case wazeroir.UnsignedTypeI32:
 		instruction = x86.ASUBL
 		tp = generalPurposeRegisterTypeInt
 		panic("add tests!")
-	case wazeroir.SignLessTypeI64:
+	case wazeroir.UnsignedTypeI64:
 		instruction = x86.ASUBQ
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignLessTypeF32:
+	case wazeroir.UnsignedTypeF32:
 		instruction = x86.ASUBSS
 		tp = generalPurposeRegisterTypeFloat
 		panic("add tests!")
-	case wazeroir.SignLessTypeF64:
+	case wazeroir.UnsignedTypeF64:
 		instruction = x86.ASUBSD
 		tp = generalPurposeRegisterTypeFloat
 		panic("add tests!")
@@ -1031,26 +1031,26 @@ func (b *amd64Builder) handleLe(o *wazeroir.OperationLe) error {
 	var instruction obj.As
 	var tp generalPurposeRegisterType
 	switch o.Type {
-	case wazeroir.SignFulTypeInt32:
+	case wazeroir.SignedTypeInt32:
 		resultConditionState = conditionalRegisterStateLE
 		instruction = x86.ACMPL
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignFulTypeUint32:
+	case wazeroir.SignedTypeUint32:
 		resultConditionState = conditionalRegisterStateBE
 		instruction = x86.ACMPL
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignFulTypeInt64:
+	case wazeroir.SignedTypeInt64:
 		resultConditionState = conditionalRegisterStateLE
 		instruction = x86.ACMPQ
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignFulTypeUint64:
+	case wazeroir.SignedTypeUint64:
 		resultConditionState = conditionalRegisterStateBE
 		instruction = x86.ACMPQ
 		tp = generalPurposeRegisterTypeInt
-	case wazeroir.SignFulTypeFloat32:
+	case wazeroir.SignedTypeFloat32:
 		tp = generalPurposeRegisterTypeFloat
 		panic("add test!")
-	case wazeroir.SignFulTypeFloat64:
+	case wazeroir.SignedTypeFloat64:
 		tp = generalPurposeRegisterTypeFloat
 		panic("add test!")
 	}
@@ -1094,7 +1094,7 @@ func (b *amd64Builder) handleLe(o *wazeroir.OperationLe) error {
 	// Finally we have the result on the conditional register,
 	// so record it.
 	loc := b.locationStack.pushValueOnConditionalRegister(resultConditionState)
-	loc.setValueType(wazeroir.SignLessTypeI32)
+	loc.setValueType(wazeroir.UnsignedTypeI32)
 	return nil
 }
 
@@ -1131,16 +1131,16 @@ func (b *amd64Builder) handleLoad(o *wazeroir.OperationLoad) error {
 		movInst   obj.As
 	)
 	switch o.Type {
-	case wazeroir.SignLessTypeI32:
+	case wazeroir.UnsignedTypeI32:
 		isIntType = true
 		movInst = x86.AMOVL
-	case wazeroir.SignLessTypeI64:
+	case wazeroir.UnsignedTypeI64:
 		isIntType = true
 		movInst = x86.AMOVQ
-	case wazeroir.SignLessTypeF32:
+	case wazeroir.UnsignedTypeF32:
 		isIntType = false
 		movInst = x86.AMOVL
-	case wazeroir.SignLessTypeF64:
+	case wazeroir.UnsignedTypeF64:
 		isIntType = false
 		movInst = x86.AMOVQ
 	}
@@ -1189,7 +1189,7 @@ func (b *amd64Builder) handleMemoryGrow() {
 func (b *amd64Builder) handleMemorySize() {
 	b.callBuiltinFunctionFromConstIndex(builtinFunctionIndexMemorySize)
 	loc := b.locationStack.pushValueOnStack() // The size is pushed on the top.
-	loc.setValueType(wazeroir.SignLessTypeI32)
+	loc.setValueType(wazeroir.UnsignedTypeI32)
 }
 
 func (b *amd64Builder) callBuiltinFunctionFromConstIndex(index int64) {
@@ -1209,7 +1209,7 @@ func (b *amd64Builder) handleConstI32(o *wazeroir.OperationConstI32) error {
 		return err
 	}
 	loc := b.locationStack.pushValueOnRegister(reg)
-	loc.setValueType(wazeroir.SignLessTypeI32)
+	loc.setValueType(wazeroir.UnsignedTypeI32)
 
 	prog := b.newProg()
 	prog.As = x86.AMOVL // Note 32-bit move!
@@ -1227,7 +1227,7 @@ func (b *amd64Builder) handleConstI64(o *wazeroir.OperationConstI64) error {
 		return err
 	}
 	loc := b.locationStack.pushValueOnRegister(reg)
-	loc.setValueType(wazeroir.SignLessTypeI64)
+	loc.setValueType(wazeroir.UnsignedTypeI64)
 
 	prog := b.newProg()
 	prog.As = x86.AMOVQ
@@ -1245,7 +1245,7 @@ func (b *amd64Builder) handleConstF32(o *wazeroir.OperationConstF32) error {
 		return err
 	}
 	loc := b.locationStack.pushValueOnRegister(reg)
-	loc.setValueType(wazeroir.SignLessTypeF32)
+	loc.setValueType(wazeroir.UnsignedTypeF32)
 
 	// We cannot directly load the value from memory to float regs,
 	// so we move it to int reg temporarily.
@@ -1279,7 +1279,7 @@ func (b *amd64Builder) handleConstF64(o *wazeroir.OperationConstF64) error {
 		return err
 	}
 	loc := b.locationStack.pushValueOnRegister(reg)
-	loc.setValueType(wazeroir.SignLessTypeF64)
+	loc.setValueType(wazeroir.UnsignedTypeF64)
 
 	// We cannot directly load the value from memory to float regs,
 	// so we move it to int reg temporarily.
diff --git a/wasm/jit/jit_value_location_amd64.go b/wasm/jit/jit_value_location_amd64.go
index e04e4aa8..760d3d23 100644
--- a/wasm/jit/jit_value_location_amd64.go
+++ b/wasm/jit/jit_value_location_amd64.go
@@ -68,7 +68,7 @@ const (
 // and it has the information about where it exists in the physical machine.
 // It might exist in registers, or maybe on in the non-virtual physical stack allocated in memory.
 type valueLocation struct {
-	valueType wazeroir.SignLessType
+	valueType wazeroir.UnsignedType
 	// Set to -1 if the value is stored in the memory stack.
 	register int16
 	// Set to conditionalRegisterStateUnset if the value is not on the conditional register.
@@ -80,9 +80,9 @@ type valueLocation struct {
 
 func (v *valueLocation) registerType() (t generalPurposeRegisterType) {
 	switch v.valueType {
-	case wazeroir.SignLessTypeI32, wazeroir.SignLessTypeI64:
+	case wazeroir.UnsignedTypeI32, wazeroir.UnsignedTypeI64:
 		t = generalPurposeRegisterTypeInt
-	case wazeroir.SignLessTypeF32, wazeroir.SignLessTypeF64:
+	case wazeroir.UnsignedTypeF32, wazeroir.UnsignedTypeF64:
 		t = generalPurposeRegisterTypeFloat
 	default:
 		panic("unreachable")
@@ -90,7 +90,7 @@ func (v *valueLocation) registerType() (t generalPurposeRegisterType) {
 	return
 }
 
-func (v *valueLocation) setValueType(t wazeroir.SignLessType) {
+func (v *valueLocation) setValueType(t wazeroir.UnsignedType) {
 	v.valueType = t
 }
 
diff --git a/wasm/wazeroir/compiler.go b/wasm/wazeroir/compiler.go
index 6ac6a7eb..a66c21a9 100644
--- a/wasm/wazeroir/compiler.go
+++ b/wasm/wazeroir/compiler.go
@@ -28,7 +28,7 @@ type (
 	controlFrame struct {
 		frameID          uint32
 		originalStackLen int
-		returns          []SignLessType
+		returns          []UnsignedType
 		kind             controlFrameKind
 	}
 	controlFrames struct{ frames []*controlFrame }
@@ -103,7 +103,7 @@ func (c *controlFrames) push(frame *controlFrame) {
 }
 
 type compiler struct {
-	stack            []SignLessType
+	stack            []UnsignedType
 	currentID        uint32
 	controlFrames    *controlFrames
 	unreachableState struct {
@@ -149,7 +149,7 @@ func Compile(f *wasm.FunctionInstance) (*CompilationResult, error) {
 
 	// Push function arguments.
 	for _, t := range f.Signature.InputTypes {
-		c.stackPush(WasmValueTypeToSignless(t))
+		c.stackPush(WasmValueTypeToUnsignedType(t))
 	}
 	// Emit const expressions for locals.
 	// Note that here we don't take function arguments
@@ -160,9 +160,9 @@ func Compile(f *wasm.FunctionInstance) (*CompilationResult, error) {
 	}
 
 	// Insert the function control frame.
-	returns := make([]SignLessType, 0, len(f.Signature.ReturnTypes))
+	returns := make([]UnsignedType, 0, len(f.Signature.ReturnTypes))
 	for _, t := range f.Signature.ReturnTypes {
-		returns = append(returns, WasmValueTypeToSignless(t))
+		returns = append(returns, WasmValueTypeToUnsignedType(t))
 	}
 	c.controlFrames.push(&controlFrame{
 		frameID:          c.nextID(),
@@ -232,7 +232,7 @@ operatorSwitch:
 			kind:             controlFrameKindBlockWithoutContinuationLabel,
 		}
 		for _, t := range bt.ReturnTypes {
-			frame.returns = append(frame.returns, WasmValueTypeToSignless(t))
+			frame.returns = append(frame.returns, WasmValueTypeToUnsignedType(t))
 		}
 		c.controlFrames.push(frame)
 
@@ -258,7 +258,7 @@ operatorSwitch:
 			kind:             controlFrameKindLoop,
 		}
 		for _, t := range bt.ReturnTypes {
-			frame.returns = append(frame.returns, WasmValueTypeToSignless(t))
+			frame.returns = append(frame.returns, WasmValueTypeToUnsignedType(t))
 		}
 		c.controlFrames.push(frame)
 
@@ -298,7 +298,7 @@ operatorSwitch:
 			kind: controlFrameKindIfWithoutElse,
 		}
 		for _, t := range bt.ReturnTypes {
-			frame.returns = append(frame.returns, WasmValueTypeToSignless(t))
+			frame.returns = append(frame.returns, WasmValueTypeToUnsignedType(t))
 		}
 		c.controlFrames.push(frame)
 
@@ -644,7 +644,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad{Type: SignLessTypeI32, Arg: imm},
+			&OperationLoad{Type: UnsignedTypeI32, Arg: imm},
 		)
 	case wasm.OpcodeI64Load:
 		imm, err := c.readMemoryImmediate("i64.load")
@@ -652,7 +652,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad{Type: SignLessTypeI64, Arg: imm},
+			&OperationLoad{Type: UnsignedTypeI64, Arg: imm},
 		)
 	case wasm.OpcodeF32Load:
 		imm, err := c.readMemoryImmediate("f32.load")
@@ -660,7 +660,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad{Type: SignLessTypeF32, Arg: imm},
+			&OperationLoad{Type: UnsignedTypeF32, Arg: imm},
 		)
 	case wasm.OpcodeF64Load:
 		imm, err := c.readMemoryImmediate("f64.load")
@@ -668,7 +668,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad{Type: SignLessTypeF64, Arg: imm},
+			&OperationLoad{Type: UnsignedTypeF64, Arg: imm},
 		)
 	case wasm.OpcodeI32Load8S:
 		imm, err := c.readMemoryImmediate("i32.load8_s")
@@ -676,7 +676,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad8{Type: SignFulInt32, Arg: imm},
+			&OperationLoad8{Type: SignedInt32, Arg: imm},
 		)
 	case wasm.OpcodeI32Load8U:
 		imm, err := c.readMemoryImmediate("i32.load8_u")
@@ -684,7 +684,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad8{Type: SignFulUint32, Arg: imm},
+			&OperationLoad8{Type: SignedUint32, Arg: imm},
 		)
 	case wasm.OpcodeI32Load16S:
 		imm, err := c.readMemoryImmediate("i32.load16_s")
@@ -692,7 +692,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad16{Type: SignFulInt32, Arg: imm},
+			&OperationLoad16{Type: SignedInt32, Arg: imm},
 		)
 	case wasm.OpcodeI32Load16U:
 		imm, err := c.readMemoryImmediate("i32.load16_u")
@@ -700,7 +700,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad16{Type: SignFulUint32, Arg: imm},
+			&OperationLoad16{Type: SignedUint32, Arg: imm},
 		)
 	case wasm.OpcodeI64Load8S:
 		imm, err := c.readMemoryImmediate("i64.load8_s")
@@ -708,7 +708,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad8{Type: SignFulInt64, Arg: imm},
+			&OperationLoad8{Type: SignedInt64, Arg: imm},
 		)
 	case wasm.OpcodeI64Load8U:
 		imm, err := c.readMemoryImmediate("i64.load8_u")
@@ -716,7 +716,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad8{Type: SignFulUint64, Arg: imm},
+			&OperationLoad8{Type: SignedUint64, Arg: imm},
 		)
 	case wasm.OpcodeI64Load16S:
 		imm, err := c.readMemoryImmediate("i64.load16_s")
@@ -724,7 +724,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad16{Type: SignFulInt64, Arg: imm},
+			&OperationLoad16{Type: SignedInt64, Arg: imm},
 		)
 	case wasm.OpcodeI64Load16U:
 		imm, err := c.readMemoryImmediate("i64.load16_u")
@@ -732,7 +732,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationLoad16{Type: SignFulUint64, Arg: imm},
+			&OperationLoad16{Type: SignedUint64, Arg: imm},
 		)
 	case wasm.OpcodeI64Load32S:
 		imm, err := c.readMemoryImmediate("i64.load32_s")
@@ -756,7 +756,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore{Type: SignLessTypeI32, Arg: imm},
+			&OperationStore{Type: UnsignedTypeI32, Arg: imm},
 		)
 	case wasm.OpcodeI64Store:
 		imm, err := c.readMemoryImmediate("i64.store")
@@ -764,7 +764,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore{Type: SignLessTypeI64, Arg: imm},
+			&OperationStore{Type: UnsignedTypeI64, Arg: imm},
 		)
 	case wasm.OpcodeF32Store:
 		imm, err := c.readMemoryImmediate("f32.store")
@@ -772,7 +772,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore{Type: SignLessTypeF32, Arg: imm},
+			&OperationStore{Type: UnsignedTypeF32, Arg: imm},
 		)
 	case wasm.OpcodeF64Store:
 		imm, err := c.readMemoryImmediate("f64.store")
@@ -780,7 +780,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore{Type: SignLessTypeF64, Arg: imm},
+			&OperationStore{Type: UnsignedTypeF64, Arg: imm},
 		)
 	case wasm.OpcodeI32Store8:
 		imm, err := c.readMemoryImmediate("i32.store8")
@@ -788,7 +788,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore8{Type: SignLessInt32, Arg: imm},
+			&OperationStore8{Type: UnsignedInt32, Arg: imm},
 		)
 	case wasm.OpcodeI32Store16:
 		imm, err := c.readMemoryImmediate("i32.store16")
@@ -796,7 +796,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore16{Type: SignLessInt32, Arg: imm},
+			&OperationStore16{Type: UnsignedInt32, Arg: imm},
 		)
 	case wasm.OpcodeI64Store8:
 		imm, err := c.readMemoryImmediate("i64.store8")
@@ -804,7 +804,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore8{Type: SignLessInt64, Arg: imm},
+			&OperationStore8{Type: UnsignedInt64, Arg: imm},
 		)
 	case wasm.OpcodeI64Store16:
 		imm, err := c.readMemoryImmediate("i64.store16")
@@ -812,7 +812,7 @@ operatorSwitch:
 			return err
 		}
 		c.emit(
-			&OperationStore16{Type: SignLessInt64, Arg: imm},
+			&OperationStore16{Type: UnsignedInt64, Arg: imm},
 		)
 	case wasm.OpcodeI64Store32:
 		imm, err := c.readMemoryImmediate("i64.store32")
@@ -864,283 +864,283 @@ operatorSwitch:
 		)
 	case wasm.OpcodeI32Eqz:
 		c.emit(
-			&OperationEqz{Type: SignLessInt32},
+			&OperationEqz{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Eq:
 		c.emit(
-			&OperationEq{Type: SignLessTypeI32},
+			&OperationEq{Type: UnsignedTypeI32},
 		)
 	case wasm.OpcodeI32Ne:
 		c.emit(
-			&OperationNe{Type: SignLessTypeI32},
+			&OperationNe{Type: UnsignedTypeI32},
 		)
 	case wasm.OpcodeI32LtS:
 		c.emit(
-			&OperationLt{Type: SignFulTypeInt32},
+			&OperationLt{Type: SignedTypeInt32},
 		)
 	case wasm.OpcodeI32LtU:
 		c.emit(
-			&OperationLt{Type: SignFulTypeUint32},
+			&OperationLt{Type: SignedTypeUint32},
 		)
 	case wasm.OpcodeI32GtS:
 		c.emit(
-			&OperationGt{Type: SignFulTypeInt32},
+			&OperationGt{Type: SignedTypeInt32},
 		)
 	case wasm.OpcodeI32GtU:
 		c.emit(
-			&OperationGt{Type: SignFulTypeUint32},
+			&OperationGt{Type: SignedTypeUint32},
 		)
 	case wasm.OpcodeI32LeS:
 		c.emit(
-			&OperationLe{Type: SignFulTypeInt32},
+			&OperationLe{Type: SignedTypeInt32},
 		)
 	case wasm.OpcodeI32LeU:
 		c.emit(
-			&OperationLe{Type: SignFulTypeUint32},
+			&OperationLe{Type: SignedTypeUint32},
 		)
 	case wasm.OpcodeI32GeS:
 		c.emit(
-			&OperationGe{Type: SignFulTypeInt32},
+			&OperationGe{Type: SignedTypeInt32},
 		)
 	case wasm.OpcodeI32GeU:
 		c.emit(
-			&OperationGe{Type: SignFulTypeUint32},
+			&OperationGe{Type: SignedTypeUint32},
 		)
 	case wasm.OpcodeI64Eqz:
 		c.emit(
-			&OperationEqz{Type: SignLessInt64},
+			&OperationEqz{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Eq:
 		c.emit(
-			&OperationEq{Type: SignLessTypeI64},
+			&OperationEq{Type: UnsignedTypeI64},
 		)
 	case wasm.OpcodeI64Ne:
 		c.emit(
-			&OperationNe{Type: SignLessTypeI64},
+			&OperationNe{Type: UnsignedTypeI64},
 		)
 	case wasm.OpcodeI64LtS:
 		c.emit(
-			&OperationLt{Type: SignFulTypeInt64},
+			&OperationLt{Type: SignedTypeInt64},
 		)
 	case wasm.OpcodeI64LtU:
 		c.emit(
-			&OperationLt{Type: SignFulTypeUint64},
+			&OperationLt{Type: SignedTypeUint64},
 		)
 	case wasm.OpcodeI64GtS:
 		c.emit(
-			&OperationGt{Type: SignFulTypeInt64},
+			&OperationGt{Type: SignedTypeInt64},
 		)
 	case wasm.OpcodeI64GtU:
 		c.emit(
-			&OperationGt{Type: SignFulTypeUint64},
+			&OperationGt{Type: SignedTypeUint64},
 		)
 	case wasm.OpcodeI64LeS:
 		c.emit(
-			&OperationLe{Type: SignFulTypeInt64},
+			&OperationLe{Type: SignedTypeInt64},
 		)
 	case wasm.OpcodeI64LeU:
 		c.emit(
-			&OperationLe{Type: SignFulTypeUint64},
+			&OperationLe{Type: SignedTypeUint64},
 		)
 	case wasm.OpcodeI64GeS:
 		c.emit(
-			&OperationGe{Type: SignFulTypeInt64},
+			&OperationGe{Type: SignedTypeInt64},
 		)
 	case wasm.OpcodeI64GeU:
 		c.emit(
-			&OperationGe{Type: SignFulTypeUint64},
+			&OperationGe{Type: SignedTypeUint64},
 		)
 	case wasm.OpcodeF32Eq:
 		c.emit(
-			&OperationEq{Type: SignLessTypeF32},
+			&OperationEq{Type: UnsignedTypeF32},
 		)
 	case wasm.OpcodeF32Ne:
 		c.emit(
-			&OperationNe{Type: SignLessTypeF32},
+			&OperationNe{Type: UnsignedTypeF32},
 		)
 	case wasm.OpcodeF32Lt:
 		c.emit(
-			&OperationLt{Type: SignFulTypeFloat32},
+			&OperationLt{Type: SignedTypeFloat32},
 		)
 	case wasm.OpcodeF32Gt:
 		c.emit(
-			&OperationGt{Type: SignFulTypeFloat32},
+			&OperationGt{Type: SignedTypeFloat32},
 		)
 	case wasm.OpcodeF32Le:
 		c.emit(
-			&OperationLe{Type: SignFulTypeFloat32},
+			&OperationLe{Type: SignedTypeFloat32},
 		)
 	case wasm.OpcodeF32Ge:
 		c.emit(
-			&OperationGe{Type: SignFulTypeFloat32},
+			&OperationGe{Type: SignedTypeFloat32},
 		)
 	case wasm.OpcodeF64Eq:
 		c.emit(
-			&OperationEq{Type: SignLessTypeF64},
+			&OperationEq{Type: UnsignedTypeF64},
 		)
 	case wasm.OpcodeF64Ne:
 		c.emit(
-			&OperationNe{Type: SignLessTypeF64},
+			&OperationNe{Type: UnsignedTypeF64},
 		)
 	case wasm.OpcodeF64Lt:
 		c.emit(
-			&OperationLt{Type: SignFulTypeFloat64},
+			&OperationLt{Type: SignedTypeFloat64},
 		)
 	case wasm.OpcodeF64Gt:
 		c.emit(
-			&OperationGt{Type: SignFulTypeFloat64},
+			&OperationGt{Type: SignedTypeFloat64},
 		)
 	case wasm.OpcodeF64Le:
 		c.emit(
-			&OperationLe{Type: SignFulTypeFloat64},
+			&OperationLe{Type: SignedTypeFloat64},
 		)
 	case wasm.OpcodeF64Ge:
 		c.emit(
-			&OperationGe{Type: SignFulTypeFloat64},
+			&OperationGe{Type: SignedTypeFloat64},
 		)
 	case wasm.OpcodeI32Clz:
 		c.emit(
-			&OperationClz{Type: SignLessInt32},
+			&OperationClz{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Ctz:
 		c.emit(
-			&OperationCtz{Type: SignLessInt32},
+			&OperationCtz{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Popcnt:
 		c.emit(
-			&OperationPopcnt{Type: SignLessInt32},
+			&OperationPopcnt{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Add:
 		c.emit(
-			&OperationAdd{Type: SignLessTypeI32},
+			&OperationAdd{Type: UnsignedTypeI32},
 		)
 	case wasm.OpcodeI32Sub:
 		c.emit(
-			&OperationSub{Type: SignLessTypeI32},
+			&OperationSub{Type: UnsignedTypeI32},
 		)
 	case wasm.OpcodeI32Mul:
 		c.emit(
-			&OperationMul{Type: SignLessTypeI32},
+			&OperationMul{Type: UnsignedTypeI32},
 		)
 	case wasm.OpcodeI32DivS:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeInt32},
+			&OperationDiv{Type: SignedTypeInt32},
 		)
 	case wasm.OpcodeI32DivU:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeUint32},
+			&OperationDiv{Type: SignedTypeUint32},
 		)
 	case wasm.OpcodeI32RemS:
 		c.emit(
-			&OperationRem{Type: SignFulInt32},
+			&OperationRem{Type: SignedInt32},
 		)
 	case wasm.OpcodeI32RemU:
 		c.emit(
-			&OperationRem{Type: SignFulUint32},
+			&OperationRem{Type: SignedUint32},
 		)
 	case wasm.OpcodeI32And:
 		c.emit(
-			&OperationAnd{Type: SignLessInt32},
+			&OperationAnd{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Or:
 		c.emit(
-			&OperationOr{Type: SignLessInt32},
+			&OperationOr{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Xor:
 		c.emit(
-			&OperationXor{Type: SignLessInt64},
+			&OperationXor{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI32Shl:
 		c.emit(
-			&OperationShl{Type: SignLessInt32},
+			&OperationShl{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32ShrS:
 		c.emit(
-			&OperationShr{Type: SignFulInt32},
+			&OperationShr{Type: SignedInt32},
 		)
 	case wasm.OpcodeI32ShrU:
 		c.emit(
-			&OperationShr{Type: SignFulUint32},
+			&OperationShr{Type: SignedUint32},
 		)
 	case wasm.OpcodeI32Rotl:
 		c.emit(
-			&OperationRotl{Type: SignLessInt32},
+			&OperationRotl{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI32Rotr:
 		c.emit(
-			&OperationRotr{Type: SignLessInt32},
+			&OperationRotr{Type: UnsignedInt32},
 		)
 	case wasm.OpcodeI64Clz:
 		c.emit(
-			&OperationClz{Type: SignLessInt64},
+			&OperationClz{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Ctz:
 		c.emit(
-			&OperationCtz{Type: SignLessInt64},
+			&OperationCtz{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Popcnt:
 		c.emit(
-			&OperationPopcnt{Type: SignLessInt64},
+			&OperationPopcnt{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Add:
 		c.emit(
-			&OperationAdd{Type: SignLessTypeI64},
+			&OperationAdd{Type: UnsignedTypeI64},
 		)
 	case wasm.OpcodeI64Sub:
 		c.emit(
-			&OperationSub{Type: SignLessTypeI64},
+			&OperationSub{Type: UnsignedTypeI64},
 		)
 	case wasm.OpcodeI64Mul:
 		c.emit(
-			&OperationMul{Type: SignLessTypeI64},
+			&OperationMul{Type: UnsignedTypeI64},
 		)
 	case wasm.OpcodeI64DivS:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeInt64},
+			&OperationDiv{Type: SignedTypeInt64},
 		)
 	case wasm.OpcodeI64DivU:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeUint64},
+			&OperationDiv{Type: SignedTypeUint64},
 		)
 	case wasm.OpcodeI64RemS:
 		c.emit(
-			&OperationRem{Type: SignFulInt64},
+			&OperationRem{Type: SignedInt64},
 		)
 	case wasm.OpcodeI64RemU:
 		c.emit(
-			&OperationRem{Type: SignFulUint64},
+			&OperationRem{Type: SignedUint64},
 		)
 	case wasm.OpcodeI64And:
 		c.emit(
-			&OperationAnd{Type: SignLessInt64},
+			&OperationAnd{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Or:
 		c.emit(
-			&OperationOr{Type: SignLessInt64},
+			&OperationOr{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Xor:
 		c.emit(
-			&OperationXor{Type: SignLessInt64},
+			&OperationXor{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Shl:
 		c.emit(
-			&OperationShl{Type: SignLessInt64},
+			&OperationShl{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64ShrS:
 		c.emit(
-			&OperationShr{Type: SignFulInt64},
+			&OperationShr{Type: SignedInt64},
 		)
 	case wasm.OpcodeI64ShrU:
 		c.emit(
-			&OperationShr{Type: SignFulUint64},
+			&OperationShr{Type: SignedUint64},
 		)
 	case wasm.OpcodeI64Rotl:
 		c.emit(
-			&OperationRotl{Type: SignLessInt64},
+			&OperationRotl{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeI64Rotr:
 		c.emit(
-			&OperationRotr{Type: SignLessInt64},
+			&OperationRotr{Type: UnsignedInt64},
 		)
 	case wasm.OpcodeF32Abs:
 		c.emit(
@@ -1172,19 +1172,19 @@ operatorSwitch:
 		)
 	case wasm.OpcodeF32Add:
 		c.emit(
-			&OperationAdd{Type: SignLessTypeF32},
+			&OperationAdd{Type: UnsignedTypeF32},
 		)
 	case wasm.OpcodeF32Sub:
 		c.emit(
-			&OperationSub{Type: SignLessTypeF32},
+			&OperationSub{Type: UnsignedTypeF32},
 		)
 	case wasm.OpcodeF32Mul:
 		c.emit(
-			&OperationMul{Type: SignLessTypeF32},
+			&OperationMul{Type: UnsignedTypeF32},
 		)
 	case wasm.OpcodeF32Div:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeFloat32},
+			&OperationDiv{Type: SignedTypeFloat32},
 		)
 	case wasm.OpcodeF32Min:
 		c.emit(
@@ -1228,19 +1228,19 @@ operatorSwitch:
 		)
 	case wasm.OpcodeF64Add:
 		c.emit(
-			&OperationAdd{Type: SignLessTypeF64},
+			&OperationAdd{Type: UnsignedTypeF64},
 		)
 	case wasm.OpcodeF64Sub:
 		c.emit(
-			&OperationSub{Type: SignLessTypeF64},
+			&OperationSub{Type: UnsignedTypeF64},
 		)
 	case wasm.OpcodeF64Mul:
 		c.emit(
-			&OperationMul{Type: SignLessTypeF64},
+			&OperationMul{Type: UnsignedTypeF64},
 		)
 	case wasm.OpcodeF64Div:
 		c.emit(
-			&OperationDiv{Type: SignFulTypeFloat64},
+			&OperationDiv{Type: SignedTypeFloat64},
 		)
 	case wasm.OpcodeF64Min:
 		c.emit(
@@ -1260,19 +1260,19 @@ operatorSwitch:
 		)
 	case wasm.OpcodeI32TruncF32S:
 		c.emit(
-			&OperationITruncFromF{InputType: Float32, OutputType: SignFulInt32},
+			&OperationITruncFromF{InputType: Float32, OutputType: SignedInt32},
 		)
 	case wasm.OpcodeI32TruncF32U:
 		c.emit(
-			&OperationITruncFromF{InputType: Float32, OutputType: SignFulUint32},
+			&OperationITruncFromF{InputType: Float32, OutputType: SignedUint32},
 		)
 	case wasm.OpcodeI32TruncF64S:
 		c.emit(
-			&OperationITruncFromF{InputType: Float64, OutputType: SignFulInt32},
+			&OperationITruncFromF{InputType: Float64, OutputType: SignedInt32},
 		)
 	case wasm.OpcodeI32TruncF64U:
 		c.emit(
-			&OperationITruncFromF{InputType: Float64, OutputType: SignFulUint32},
+			&OperationITruncFromF{InputType: Float64, OutputType: SignedUint32},
 		)
 	case wasm.OpcodeI64ExtendI32S:
 		c.emit(
@@ -1284,35 +1284,35 @@ operatorSwitch:
 		)
 	case wasm.OpcodeI64TruncF32S:
 		c.emit(
-			&OperationITruncFromF{InputType: Float32, OutputType: SignFulInt64},
+			&OperationITruncFromF{InputType: Float32, OutputType: SignedInt64},
 		)
 	case wasm.OpcodeI64TruncF32U:
 		c.emit(
-			&OperationITruncFromF{InputType: Float32, OutputType: SignFulUint64},
+			&OperationITruncFromF{InputType: Float32, OutputType: SignedUint64},
 		)
 	case wasm.OpcodeI64TruncF64S:
 		c.emit(
-			&OperationITruncFromF{InputType: Float64, OutputType: SignFulInt64},
+			&OperationITruncFromF{InputType: Float64, OutputType: SignedInt64},
 		)
 	case wasm.OpcodeI64TruncF64U:
 		c.emit(
-			&OperationITruncFromF{InputType: Float64, OutputType: SignFulUint64},
+			&OperationITruncFromF{InputType: Float64, OutputType: SignedUint64},
 		)
 	case wasm.OpcodeF32ConvertI32s:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulInt32, OutputType: Float32},
+			&OperationFConvertFromI{InputType: SignedInt32, OutputType: Float32},
 		)
 	case wasm.OpcodeF32ConvertI32U:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulUint32, OutputType: Float32},
+			&OperationFConvertFromI{InputType: SignedUint32, OutputType: Float32},
 		)
 	case wasm.OpcodeF32ConvertI64S:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulInt64, OutputType: Float32},
+			&OperationFConvertFromI{InputType: SignedInt64, OutputType: Float32},
 		)
 	case wasm.OpcodeF32ConvertI64U:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulUint64, OutputType: Float32},
+			&OperationFConvertFromI{InputType: SignedUint64, OutputType: Float32},
 		)
 	case wasm.OpcodeF32DemoteF64:
 		c.emit(
@@ -1320,19 +1320,19 @@ operatorSwitch:
 		)
 	case wasm.OpcodeF64ConvertI32S:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulInt32, OutputType: Float64},
+			&OperationFConvertFromI{InputType: SignedInt32, OutputType: Float64},
 		)
 	case wasm.OpcodeF64ConvertI32U:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulUint32, OutputType: Float64},
+			&OperationFConvertFromI{InputType: SignedUint32, OutputType: Float64},
 		)
 	case wasm.OpcodeF64ConvertI64S:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulInt64, OutputType: Float64},
+			&OperationFConvertFromI{InputType: SignedInt64, OutputType: Float64},
 		)
 	case wasm.OpcodeF64ConvertI64U:
 		c.emit(
-			&OperationFConvertFromI{InputType: SignFulUint64, OutputType: Float64},
+			&OperationFConvertFromI{InputType: SignedUint64, OutputType: Float64},
 		)
 	case wasm.OpcodeF64PromoteF32:
 		c.emit(
@@ -1413,13 +1413,13 @@ func (c *compiler) applyToStack(opcode wasm.Opcode) (*uint32, error) {
 	// the unknown type is unique in the signature,
 	// and is determined by the actual type on the stack.
 	// The determined type is stored in this typeParam.
-	var typeParam *SignLessType
+	var typeParam *UnsignedType
 	for i := range s.in {
 		want := s.in[len(s.in)-1-i]
 		actual := c.stackPop()
-		if want == SignLessTypeUnknown && typeParam != nil {
+		if want == UnsignedTypeUnknown && typeParam != nil {
 			want = *typeParam
-		} else if want == SignLessTypeUnknown {
+		} else if want == UnsignedTypeUnknown {
 			want = actual
 			typeParam = &actual
 		}
@@ -1429,9 +1429,9 @@ func (c *compiler) applyToStack(opcode wasm.Opcode) (*uint32, error) {
 	}
 
 	for _, target := range s.out {
-		if target == SignLessTypeUnknown && typeParam == nil {
+		if target == UnsignedTypeUnknown && typeParam == nil {
 			return nil, fmt.Errorf("cannot determine type of unknown result")
-		} else if target == SignLessTypeUnknown {
+		} else if target == UnsignedTypeUnknown {
 			c.stackPush(*typeParam)
 		} else {
 			c.stackPush(target)
@@ -1441,7 +1441,7 @@ func (c *compiler) applyToStack(opcode wasm.Opcode) (*uint32, error) {
 	return ptr, nil
 }
 
-func (c *compiler) stackPop() (ret SignLessType) {
+func (c *compiler) stackPop() (ret UnsignedType) {
 	// No need to check stack bound
 	// as we can assume that all the operations
 	// are valid thanks to analyzeFunction
@@ -1451,7 +1451,7 @@ func (c *compiler) stackPop() (ret SignLessType) {
 	return
 }
 
-func (c *compiler) stackPush(t SignLessType) {
+func (c *compiler) stackPush(t UnsignedType) {
 	c.stack = append(c.stack, t)
 }
 
@@ -1482,16 +1482,16 @@ func (c *compiler) emit(ops ...Operation) {
 func (c *compiler) emitDefaultValue(t wasm.ValueType) {
 	switch t {
 	case wasm.ValueTypeI32:
-		c.stackPush(SignLessTypeI32)
+		c.stackPush(UnsignedTypeI32)
 		c.emit(&OperationConstI32{Value: 0})
 	case wasm.ValueTypeI64:
-		c.stackPush(SignLessTypeI64)
+		c.stackPush(UnsignedTypeI64)
 		c.emit(&OperationConstI64{Value: 0})
 	case wasm.ValueTypeF32:
-		c.stackPush(SignLessTypeF32)
+		c.stackPush(UnsignedTypeF32)
 		c.emit(&OperationConstF32{Value: 0})
 	case wasm.ValueTypeF64:
-		c.stackPush(SignLessTypeF64)
+		c.stackPush(UnsignedTypeF64)
 		c.emit(&OperationConstF64{Value: 0})
 	}
 }
diff --git a/wasm/wazeroir/interpreter.go b/wasm/wazeroir/interpreter.go
index 405b5b88..20d95793 100644
--- a/wasm/wazeroir/interpreter.go
+++ b/wasm/wazeroir/interpreter.go
@@ -651,10 +651,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 		case OperationKindLoad:
 			{
 				base := op.us[1] + it.pop()
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32, SignLessTypeF32:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32, UnsignedTypeF32:
 					it.push(uint64(binary.LittleEndian.Uint32(memoryInst.Buffer[base:])))
-				case SignLessTypeI64, SignLessTypeF64:
+				case UnsignedTypeI64, UnsignedTypeF64:
 					it.push(binary.LittleEndian.Uint64(memoryInst.Buffer[base:]))
 				}
 				frame.pc++
@@ -662,10 +662,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 		case OperationKindLoad8:
 			{
 				base := op.us[1] + it.pop()
-				switch SignFulInt(op.b1) {
-				case SignFulInt32, SignFulInt64:
+				switch SignedInt(op.b1) {
+				case SignedInt32, SignedInt64:
 					it.push(uint64(int8(memoryInst.Buffer[base])))
-				case SignFulUint32, SignFulUint64:
+				case SignedUint32, SignedUint64:
 					it.push(uint64(uint8(memoryInst.Buffer[base])))
 				}
 				frame.pc++
@@ -673,10 +673,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 		case OperationKindLoad16:
 			{
 				base := op.us[1] + it.pop()
-				switch SignFulInt(op.b1) {
-				case SignFulInt32, SignFulInt64:
+				switch SignedInt(op.b1) {
+				case SignedInt32, SignedInt64:
 					it.push(uint64(int16(binary.LittleEndian.Uint16(memoryInst.Buffer[base:]))))
-				case SignFulUint32, SignFulUint64:
+				case SignedUint32, SignedUint64:
 					it.push(uint64(binary.LittleEndian.Uint16(memoryInst.Buffer[base:])))
 				}
 				frame.pc++
@@ -695,10 +695,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				val := it.pop()
 				base := op.us[1] + it.pop()
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32, SignLessTypeF32:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32, UnsignedTypeF32:
 					binary.LittleEndian.PutUint32(memoryInst.Buffer[base:], uint32(val))
-				case SignLessTypeI64, SignLessTypeF64:
+				case UnsignedTypeI64, UnsignedTypeF64:
 					binary.LittleEndian.PutUint64(memoryInst.Buffer[base:], val)
 				}
 				frame.pc++
@@ -755,14 +755,14 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 		case OperationKindEq:
 			{
 				var b bool
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32, SignLessTypeI64:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32, UnsignedTypeI64:
 					v2, v1 := it.pop(), it.pop()
 					b = v1 == v2
-				case SignLessTypeF32:
+				case UnsignedTypeF32:
 					v2, v1 := it.pop(), it.pop()
 					b = math.Float32frombits(uint32(v2)) == math.Float32frombits(uint32(v1))
-				case SignLessTypeF64:
+				case UnsignedTypeF64:
 					v2, v1 := it.pop(), it.pop()
 					b = math.Float64frombits(v2) == math.Float64frombits(v1)
 				}
@@ -776,14 +776,14 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 		case OperationKindNe:
 			{
 				var b bool
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32, SignLessTypeI64:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32, UnsignedTypeI64:
 					v2, v1 := it.pop(), it.pop()
 					b = v1 != v2
-				case SignLessTypeF32:
+				case UnsignedTypeF32:
 					v2, v1 := it.pop(), it.pop()
 					b = math.Float32frombits(uint32(v2)) != math.Float32frombits(uint32(v1))
-				case SignLessTypeF64:
+				case UnsignedTypeF64:
 					v2, v1 := it.pop(), it.pop()
 					b = math.Float64frombits(v2) != math.Float64frombits(v1)
 				}
@@ -808,16 +808,16 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				var b bool
-				switch SignFulType(op.b1) {
-				case SignFulTypeInt32:
+				switch SignedType(op.b1) {
+				case SignedTypeInt32:
 					b = int32(v1) < int32(v2)
-				case SignFulTypeInt64:
+				case SignedTypeInt64:
 					b = int64(v1) < int64(v2)
-				case SignFulTypeUint32, SignFulTypeUint64:
+				case SignedTypeUint32, SignedTypeUint64:
 					b = v1 < v2
-				case SignFulTypeFloat32:
+				case SignedTypeFloat32:
 					b = math.Float32frombits(uint32(v1)) < math.Float32frombits(uint32(v2))
-				case SignFulTypeFloat64:
+				case SignedTypeFloat64:
 					b = math.Float64frombits(v1) < math.Float64frombits(v2)
 				}
 				if b {
@@ -832,16 +832,16 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				var b bool
-				switch SignFulType(op.b1) {
-				case SignFulTypeInt32:
+				switch SignedType(op.b1) {
+				case SignedTypeInt32:
 					b = int32(v1) > int32(v2)
-				case SignFulTypeInt64:
+				case SignedTypeInt64:
 					b = int64(v1) > int64(v2)
-				case SignFulTypeUint32, SignFulTypeUint64:
+				case SignedTypeUint32, SignedTypeUint64:
 					b = v1 > v2
-				case SignFulTypeFloat32:
+				case SignedTypeFloat32:
 					b = math.Float32frombits(uint32(v1)) > math.Float32frombits(uint32(v2))
-				case SignFulTypeFloat64:
+				case SignedTypeFloat64:
 					b = math.Float64frombits(v1) > math.Float64frombits(v2)
 				}
 				if b {
@@ -856,16 +856,16 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				var b bool
-				switch SignFulType(op.b1) {
-				case SignFulTypeInt32:
+				switch SignedType(op.b1) {
+				case SignedTypeInt32:
 					b = int32(v1) <= int32(v2)
-				case SignFulTypeInt64:
+				case SignedTypeInt64:
 					b = int64(v1) <= int64(v2)
-				case SignFulTypeUint32, SignFulTypeUint64:
+				case SignedTypeUint32, SignedTypeUint64:
 					b = v1 <= v2
-				case SignFulTypeFloat32:
+				case SignedTypeFloat32:
 					b = math.Float32frombits(uint32(v1)) <= math.Float32frombits(uint32(v2))
-				case SignFulTypeFloat64:
+				case SignedTypeFloat64:
 					b = math.Float64frombits(v1) <= math.Float64frombits(v2)
 				}
 				if b {
@@ -880,16 +880,16 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				var b bool
-				switch SignFulType(op.b1) {
-				case SignFulTypeInt32:
+				switch SignedType(op.b1) {
+				case SignedTypeInt32:
 					b = int32(v1) >= int32(v2)
-				case SignFulTypeInt64:
+				case SignedTypeInt64:
 					b = int64(v1) >= int64(v2)
-				case SignFulTypeUint32, SignFulTypeUint64:
+				case SignedTypeUint32, SignedTypeUint64:
 					b = v1 >= v2
-				case SignFulTypeFloat32:
+				case SignedTypeFloat32:
 					b = math.Float32frombits(uint32(v1)) >= math.Float32frombits(uint32(v2))
-				case SignFulTypeFloat64:
+				case SignedTypeFloat64:
 					b = math.Float64frombits(v1) >= math.Float64frombits(v2)
 				}
 				if b {
@@ -903,16 +903,16 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v2 := it.pop()
 				v1 := it.pop()
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32:
 					v := uint32(v1) + uint32(v2)
 					it.push(uint64(v))
-				case SignLessTypeI64:
+				case UnsignedTypeI64:
 					it.push(v1 + v2)
-				case SignLessTypeF32:
+				case UnsignedTypeF32:
 					v := math.Float32frombits(uint32(v1)) + math.Float32frombits(uint32(v2))
 					it.push(uint64(math.Float32bits(v)))
-				case SignLessTypeF64:
+				case UnsignedTypeF64:
 					v := math.Float64frombits(v1) + math.Float64frombits(v2)
 					it.push(math.Float64bits(v))
 				}
@@ -922,15 +922,15 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v2 := it.pop()
 				v1 := it.pop()
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32:
 					it.push(uint64(uint32(v1) - uint32(v2)))
-				case SignLessTypeI64:
+				case UnsignedTypeI64:
 					it.push(v1 - v2)
-				case SignLessTypeF32:
+				case UnsignedTypeF32:
 					v := math.Float32frombits(uint32(v1)) - math.Float32frombits(uint32(v2))
 					it.push(uint64(math.Float32bits(v)))
-				case SignLessTypeF64:
+				case UnsignedTypeF64:
 					v := math.Float64frombits(v1) - math.Float64frombits(v2)
 					it.push(math.Float64bits(v))
 				}
@@ -940,15 +940,15 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v2 := it.pop()
 				v1 := it.pop()
-				switch SignLessType(op.b1) {
-				case SignLessTypeI32:
+				switch UnsignedType(op.b1) {
+				case UnsignedTypeI32:
 					it.push(uint64(uint32(v1) * uint32(v2)))
-				case SignLessTypeI64:
+				case UnsignedTypeI64:
 					it.push(v1 * v2)
-				case SignLessTypeF32:
+				case UnsignedTypeF32:
 					v := math.Float32frombits(uint32(v2)) * math.Float32frombits(uint32(v1))
 					it.push(uint64(math.Float32bits(v)))
-				case SignLessTypeF64:
+				case UnsignedTypeF64:
 					v := math.Float64frombits(v2) * math.Float64frombits(v1)
 					it.push(math.Float64bits(v))
 				}
@@ -958,10 +958,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(bits.LeadingZeros32(uint32(v))))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(bits.LeadingZeros64(v)))
 				}
 				frame.pc++
@@ -970,10 +970,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(bits.TrailingZeros32(uint32(v))))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(bits.TrailingZeros64(v)))
 				}
 				frame.pc++
@@ -982,45 +982,45 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(bits.OnesCount32(uint32(v))))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(bits.OnesCount64(v)))
 				}
 				frame.pc++
 			}
 		case OperationKindDiv:
 			{
-				switch SignFulType(op.b1) {
-				case SignFulTypeInt32:
+				switch SignedType(op.b1) {
+				case SignedTypeInt32:
 					v2 := int32(it.pop())
 					v1 := int32(it.pop())
 					if v2 == 0 || (v1 == math.MinInt32 && v2 == -1) {
 						panic("undefined")
 					}
 					it.push(uint64(uint32(v1 / v2)))
-				case SignFulTypeInt64:
+				case SignedTypeInt64:
 					v2 := int64(it.pop())
 					v1 := int64(it.pop())
 					if v2 == 0 || (v1 == math.MinInt64 && v2 == -1) {
 						panic("undefined")
 					}
 					it.push(uint64(v1 / v2))
-				case SignFulTypeUint32:
+				case SignedTypeUint32:
 					v2 := uint32(it.pop())
 					v1 := uint32(it.pop())
 					it.push(uint64(v1 / v2))
-				case SignFulTypeUint64:
+				case SignedTypeUint64:
 					v2 := it.pop()
 					v1 := it.pop()
 					it.push(v1 / v2)
-				case SignFulTypeFloat32:
+				case SignedTypeFloat32:
 					v2 := it.pop()
 					v1 := it.pop()
 					v := math.Float32frombits(uint32(v1)) / math.Float32frombits(uint32(v2))
 					it.push(uint64(math.Float32bits(v)))
-				case SignFulTypeFloat64:
+				case SignedTypeFloat64:
 					v2 := it.pop()
 					v1 := it.pop()
 					v := math.Float64frombits(v1) / math.Float64frombits(v2)
@@ -1030,20 +1030,20 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			}
 		case OperationKindRem:
 			{
-				switch SignFulInt(op.b1) {
-				case SignFulInt32:
+				switch SignedInt(op.b1) {
+				case SignedInt32:
 					v2 := int32(it.pop())
 					v1 := int32(it.pop())
 					it.push(uint64(uint32(v1 % v2)))
-				case SignFulInt64:
+				case SignedInt64:
 					v2 := int64(it.pop())
 					v1 := int64(it.pop())
 					it.push(uint64(v1 % v2))
-				case SignFulUint32:
+				case SignedUint32:
 					v2 := uint32(it.pop())
 					v1 := uint32(it.pop())
 					it.push(uint64(v1 % v2))
-				case SignFulUint64:
+				case SignedUint64:
 					v2 := it.pop()
 					v1 := it.pop()
 					it.push(v1 % v2)
@@ -1055,10 +1055,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(uint32(v2) & uint32(v1)))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(v2 & v1))
 				}
 				frame.pc++
@@ -1068,10 +1068,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(uint32(v2) | uint32(v1)))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(v2 | v1))
 				}
 				frame.pc++
@@ -1081,10 +1081,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(uint32(v2) ^ uint32(v1)))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(v2 ^ v1))
 				}
 				frame.pc++
@@ -1094,10 +1094,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(uint32(v1) << (uint32(v2) % 32)))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(v1 << (v2 % 64))
 				}
 				frame.pc++
@@ -1106,14 +1106,14 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				v2 := it.pop()
 				v1 := it.pop()
-				switch SignFulInt(op.b1) {
-				case SignFulInt32:
+				switch SignedInt(op.b1) {
+				case SignedInt32:
 					it.push(uint64(int32(v1) >> (uint32(v2) % 32)))
-				case SignFulInt64:
+				case SignedInt64:
 					it.push(uint64(int64(v1) >> (v2 % 64)))
-				case SignFulUint32:
+				case SignedUint32:
 					it.push(uint64(uint32(v1) >> (uint32(v2) % 32)))
-				case SignFulUint64:
+				case SignedUint64:
 					it.push(v1 >> (v2 % 64))
 				}
 				frame.pc++
@@ -1123,10 +1123,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(bits.RotateLeft32(uint32(v1), int(v2))))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(bits.RotateLeft64(v1, int(v2))))
 				}
 				frame.pc++
@@ -1136,10 +1136,10 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 				v2 := it.pop()
 				v1 := it.pop()
 				if op.b1 == 0 {
-					// SignLessInt32
+					// UnsignedInt32
 					it.push(uint64(bits.RotateLeft32(uint32(v1), -int(v2))))
 				} else {
-					// SignLessInt64
+					// UnsignedInt64
 					it.push(uint64(bits.RotateLeft64(v1, -int(v2))))
 				}
 				frame.pc++
@@ -1316,8 +1316,8 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			{
 				if op.b1 == 0 {
 					// Float32
-					switch SignFulInt(op.b2) {
-					case SignFulInt32:
+					switch SignedInt(op.b2) {
+					case SignedInt32:
 						v := math.Trunc(float64(math.Float32frombits(uint32(it.pop()))))
 						if math.IsNaN(v) {
 							panic("invalid conversion")
@@ -1325,7 +1325,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(int32(v)))
-					case SignFulInt64:
+					case SignedInt64:
 						v := math.Trunc(float64(math.Float32frombits(uint32(it.pop()))))
 						res := int64(v)
 						if math.IsNaN(v) {
@@ -1334,7 +1334,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(res))
-					case SignFulUint32:
+					case SignedUint32:
 						v := math.Trunc(float64(math.Float32frombits(uint32(it.pop()))))
 						if math.IsNaN(v) {
 							panic("invalid conversion")
@@ -1342,7 +1342,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(uint32(v)))
-					case SignFulUint64:
+					case SignedUint64:
 						v := math.Trunc(float64(math.Float32frombits(uint32(it.pop()))))
 						res := uint64(v)
 						if math.IsNaN(v) {
@@ -1354,8 +1354,8 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 					}
 				} else {
 					// Float64
-					switch SignFulInt(op.b2) {
-					case SignFulInt32:
+					switch SignedInt(op.b2) {
+					case SignedInt32:
 						v := math.Trunc(math.Float64frombits(it.pop()))
 						if math.IsNaN(v) {
 							panic("invalid conversion")
@@ -1363,7 +1363,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(int32(v)))
-					case SignFulInt64:
+					case SignedInt64:
 						v := math.Trunc(math.Float64frombits(it.pop()))
 						res := int64(v)
 						if math.IsNaN(v) {
@@ -1372,7 +1372,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(res))
-					case SignFulUint32:
+					case SignedUint32:
 						v := math.Trunc(math.Float64frombits(it.pop()))
 						if math.IsNaN(v) {
 							panic("invalid conversion")
@@ -1380,7 +1380,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 							panic("integer overflow")
 						}
 						it.push(uint64(uint32(v)))
-					case SignFulUint64:
+					case SignedUint64:
 						v := math.Trunc(math.Float64frombits(it.pop()))
 						res := uint64(v)
 						if math.IsNaN(v) {
@@ -1395,8 +1395,8 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 			}
 		case OperationKindFConvertFromI:
 			{
-				switch SignFulInt(op.b1) {
-				case SignFulInt32:
+				switch SignedInt(op.b1) {
+				case SignedInt32:
 					if op.b2 == 0 {
 						// Float32
 						v := float32(int32(it.pop()))
@@ -1406,7 +1406,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 						v := float64(int32(it.pop()))
 						it.push(math.Float64bits(v))
 					}
-				case SignFulInt64:
+				case SignedInt64:
 					if op.b2 == 0 {
 						// Float32
 						v := float32(int64(it.pop()))
@@ -1416,7 +1416,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 						v := float64(int64(it.pop()))
 						it.push(math.Float64bits(v))
 					}
-				case SignFulUint32:
+				case SignedUint32:
 					if op.b2 == 0 {
 						// Float32
 						v := float32(uint32(it.pop()))
@@ -1426,7 +1426,7 @@ func (it *interpreter) callNativeFunc(f *interpreterFunction) {
 						v := float64(uint32(it.pop()))
 						it.push(math.Float64bits(v))
 					}
-				case SignFulUint64:
+				case SignedUint64:
 					if op.b2 == 0 {
 						// Float32
 						v := float32(it.pop())
diff --git a/wasm/wazeroir/operations.go b/wasm/wazeroir/operations.go
index dd4440b5..48641f86 100644
--- a/wasm/wazeroir/operations.go
+++ b/wasm/wazeroir/operations.go
@@ -2,41 +2,41 @@ package wazeroir
 
 import "fmt"
 
-type SignLessInt byte
+type UnsignedInt byte
 
 const (
-	SignLessInt32 SignLessInt = iota
-	SignLessInt64
+	UnsignedInt32 UnsignedInt = iota
+	UnsignedInt64
 )
 
-func (s SignLessInt) String() (ret string) {
+func (s UnsignedInt) String() (ret string) {
 	switch s {
-	case SignLessInt32:
+	case UnsignedInt32:
 		ret = "i32"
-	case SignLessInt64:
+	case UnsignedInt64:
 		ret = "i64"
 	}
 	return
 }
 
-type SignFulInt byte
+type SignedInt byte
 
 const (
-	SignFulInt32 SignFulInt = iota
-	SignFulInt64
-	SignFulUint32
-	SignFulUint64
+	SignedInt32 SignedInt = iota
+	SignedInt64
+	SignedUint32
+	SignedUint64
 )
 
-func (s SignFulInt) String() (ret string) {
+func (s SignedInt) String() (ret string) {
 	switch s {
-	case SignFulUint32:
+	case SignedUint32:
 		ret = "i32"
-	case SignFulUint64:
+	case SignedUint64:
 		ret = "i64"
-	case SignFulInt32:
+	case SignedInt32:
 		ret = "u32"
-	case SignFulInt64:
+	case SignedInt64:
 		ret = "u64"
 	}
 	return
@@ -59,56 +59,56 @@ func (s Float) String() (ret string) {
 	return
 }
 
-type SignLessType byte
+type UnsignedType byte
 
 const (
-	SignLessTypeI32 SignLessType = iota
-	SignLessTypeI64
-	SignLessTypeF32
-	SignLessTypeF64
-	SignLessTypeUnknown
+	UnsignedTypeI32 UnsignedType = iota
+	UnsignedTypeI64
+	UnsignedTypeF32
+	UnsignedTypeF64
+	UnsignedTypeUnknown
 )
 
-func (s SignLessType) String() (ret string) {
+func (s UnsignedType) String() (ret string) {
 	switch s {
-	case SignLessTypeI32:
+	case UnsignedTypeI32:
 		ret = "i32"
-	case SignLessTypeI64:
+	case UnsignedTypeI64:
 		ret = "i64"
-	case SignLessTypeF32:
+	case UnsignedTypeF32:
 		ret = "f32"
-	case SignLessTypeF64:
+	case UnsignedTypeF64:
 		ret = "f64"
-	case SignLessTypeUnknown:
+	case UnsignedTypeUnknown:
 		ret = "unknown"
 	}
 	return
 }
 
-type SignFulType byte
+type SignedType byte
 
 const (
-	SignFulTypeInt32 SignFulType = iota
-	SignFulTypeUint32
-	SignFulTypeInt64
-	SignFulTypeUint64
-	SignFulTypeFloat32
-	SignFulTypeFloat64
+	SignedTypeInt32 SignedType = iota
+	SignedTypeUint32
+	SignedTypeInt64
+	SignedTypeUint64
+	SignedTypeFloat32
+	SignedTypeFloat64
 )
 
-func (s SignFulType) String() (ret string) {
+func (s SignedType) String() (ret string) {
 	switch s {
-	case SignFulTypeInt32:
+	case SignedTypeInt32:
 		ret = "i32"
-	case SignFulTypeUint32:
+	case SignedTypeUint32:
 		ret = "u32"
-	case SignFulTypeInt64:
+	case SignedTypeInt64:
 		ret = "i64"
-	case SignFulTypeUint64:
+	case SignedTypeUint64:
 		ret = "u64"
-	case SignFulTypeFloat32:
+	case SignedTypeFloat32:
 		ret = "f32"
-	case SignFulTypeFloat64:
+	case SignedTypeFloat64:
 		ret = "f64"
 	}
 	return
@@ -507,7 +507,7 @@ type MemoryImmediate struct {
 }
 
 type OperationLoad struct {
-	Type SignLessType
+	Type UnsignedType
 	Arg  *MemoryImmediate
 }
 
@@ -516,7 +516,7 @@ func (o *OperationLoad) Kind() OperationKind {
 }
 
 type OperationLoad8 struct {
-	Type SignFulInt
+	Type SignedInt
 	Arg  *MemoryImmediate
 }
 
@@ -525,7 +525,7 @@ func (o *OperationLoad8) Kind() OperationKind {
 }
 
 type OperationLoad16 struct {
-	Type SignFulInt
+	Type SignedInt
 	Arg  *MemoryImmediate
 }
 
@@ -543,7 +543,7 @@ func (o *OperationLoad32) Kind() OperationKind {
 }
 
 type OperationStore struct {
-	Type SignLessType
+	Type UnsignedType
 	Arg  *MemoryImmediate
 }
 
@@ -552,7 +552,7 @@ func (o *OperationStore) Kind() OperationKind {
 }
 
 type OperationStore8 struct {
-	Type SignLessInt
+	Type UnsignedInt
 	Arg  *MemoryImmediate
 }
 
@@ -561,7 +561,7 @@ func (o *OperationStore8) Kind() OperationKind {
 }
 
 type OperationStore16 struct {
-	Type SignLessInt
+	Type UnsignedInt
 	Arg  *MemoryImmediate
 }
 
@@ -613,133 +613,133 @@ func (o *OperationConstF64) Kind() OperationKind {
 	return OperationKindConstF64
 }
 
-type OperationEq struct{ Type SignLessType }
+type OperationEq struct{ Type UnsignedType }
 
 func (o *OperationEq) Kind() OperationKind {
 	return OperationKindEq
 }
 
-type OperationNe struct{ Type SignLessType }
+type OperationNe struct{ Type UnsignedType }
 
 func (o *OperationNe) Kind() OperationKind {
 	return OperationKindNe
 }
 
-type OperationEqz struct{ Type SignLessInt }
+type OperationEqz struct{ Type UnsignedInt }
 
 func (o *OperationEqz) Kind() OperationKind {
 	return OperationKindEqz
 }
 
-type OperationLt struct{ Type SignFulType }
+type OperationLt struct{ Type SignedType }
 
 func (o *OperationLt) Kind() OperationKind {
 	return OperationKindLt
 }
 
-type OperationGt struct{ Type SignFulType }
+type OperationGt struct{ Type SignedType }
 
 func (o *OperationGt) Kind() OperationKind {
 	return OperationKindGt
 }
 
-type OperationLe struct{ Type SignFulType }
+type OperationLe struct{ Type SignedType }
 
 func (o *OperationLe) Kind() OperationKind {
 	return OperationKindLe
 }
 
-type OperationGe struct{ Type SignFulType }
+type OperationGe struct{ Type SignedType }
 
 func (o *OperationGe) Kind() OperationKind {
 	return OperationKindGe
 }
 
-type OperationAdd struct{ Type SignLessType }
+type OperationAdd struct{ Type UnsignedType }
 
 func (o *OperationAdd) Kind() OperationKind {
 	return OperationKindAdd
 }
 
-type OperationSub struct{ Type SignLessType }
+type OperationSub struct{ Type UnsignedType }
 
 func (o *OperationSub) Kind() OperationKind {
 	return OperationKindSub
 }
 
-type OperationMul struct{ Type SignLessType }
+type OperationMul struct{ Type UnsignedType }
 
 func (o *OperationMul) Kind() OperationKind {
 	return OperationKindMul
 }
 
-type OperationClz struct{ Type SignLessInt }
+type OperationClz struct{ Type UnsignedInt }
 
 func (o *OperationClz) Kind() OperationKind {
 	return OperationKindClz
 }
 
-type OperationCtz struct{ Type SignLessInt }
+type OperationCtz struct{ Type UnsignedInt }
 
 func (o *OperationCtz) Kind() OperationKind {
 	return OperationKindCtz
 }
 
-type OperationPopcnt struct{ Type SignLessInt }
+type OperationPopcnt struct{ Type UnsignedInt }
 
 func (o *OperationPopcnt) Kind() OperationKind {
 	return OperationKindPopcnt
 }
 
-type OperationDiv struct{ Type SignFulType }
+type OperationDiv struct{ Type SignedType }
 
 func (o *OperationDiv) Kind() OperationKind {
 	return OperationKindDiv
 }
 
-type OperationRem struct{ Type SignFulInt }
+type OperationRem struct{ Type SignedInt }
 
 func (o *OperationRem) Kind() OperationKind {
 	return OperationKindRem
 }
 
-type OperationAnd struct{ Type SignLessInt }
+type OperationAnd struct{ Type UnsignedInt }
 
 func (o *OperationAnd) Kind() OperationKind {
 	return OperationKindAnd
 }
 
-type OperationOr struct{ Type SignLessInt }
+type OperationOr struct{ Type UnsignedInt }
 
 func (o *OperationOr) Kind() OperationKind {
 	return OperationKindOr
 }
 
-type OperationXor struct{ Type SignLessInt }
+type OperationXor struct{ Type UnsignedInt }
 
 func (o *OperationXor) Kind() OperationKind {
 	return OperationKindXor
 }
 
-type OperationShl struct{ Type SignLessInt }
+type OperationShl struct{ Type UnsignedInt }
 
 func (o *OperationShl) Kind() OperationKind {
 	return OperationKindShl
 }
 
-type OperationShr struct{ Type SignFulInt }
+type OperationShr struct{ Type SignedInt }
 
 func (o *OperationShr) Kind() OperationKind {
 	return OperationKindShr
 }
 
-type OperationRotl struct{ Type SignLessInt }
+type OperationRotl struct{ Type UnsignedInt }
 
 func (o *OperationRotl) Kind() OperationKind {
 	return OperationKindRotl
 }
 
-type OperationRotr struct{ Type SignLessInt }
+type OperationRotr struct{ Type UnsignedInt }
 
 func (o *OperationRotr) Kind() OperationKind {
 	return OperationKindRotr
@@ -813,7 +813,7 @@ func (o *OperationI32WrapFromI64) Kind() OperationKind {
 
 type OperationITruncFromF struct {
 	InputType  Float
-	OutputType SignFulInt
+	OutputType SignedInt
 }
 
 func (o *OperationITruncFromF) Kind() OperationKind {
@@ -821,7 +821,7 @@ func (o *OperationITruncFromF) Kind() OperationKind {
 }
 
 type OperationFConvertFromI struct {
-	InputType  SignFulInt
+	InputType  SignedInt
 	OutputType Float
 }
 
diff --git a/wasm/wazeroir/signature.go b/wasm/wazeroir/signature.go
index 088bd611..2745531f 100644
--- a/wasm/wazeroir/signature.go
+++ b/wasm/wazeroir/signature.go
@@ -9,136 +9,136 @@ import (
 // signature represents how a Wasm opcode
 // manipulates the value stacks in terms of value types.
 type signature struct {
-	in, out []SignLessType
+	in, out []UnsignedType
 }
 
 var (
 	signature_None_None    = &signature{}
 	signature_Unknown_None = &signature{
-		in: []SignLessType{SignLessTypeUnknown},
+		in: []UnsignedType{UnsignedTypeUnknown},
 	}
 	signature_None_I32 = &signature{
-		out: []SignLessType{SignLessTypeI32},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_None_I64 = &signature{
-		out: []SignLessType{SignLessTypeI64},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_None_F32 = &signature{
-		out: []SignLessType{SignLessTypeF32},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_None_F64 = &signature{
-		out: []SignLessType{SignLessTypeF64},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_I32_None = &signature{
-		in: []SignLessType{SignLessTypeI32},
+		in: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_I32_I32 = &signature{
-		in:  []SignLessType{SignLessTypeI32},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_I32_I64 = &signature{
-		in:  []SignLessType{SignLessTypeI32},
-		out: []SignLessType{SignLessTypeI64},
+		in:  []UnsignedType{UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_I64_I64 = &signature{
-		in:  []SignLessType{SignLessTypeI64},
-		out: []SignLessType{SignLessTypeI64},
+		in:  []UnsignedType{UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_I32_F32 = &signature{
-		in:  []SignLessType{SignLessTypeI32},
-		out: []SignLessType{SignLessTypeF32},
+		in:  []UnsignedType{UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_I32_F64 = &signature{
-		in:  []SignLessType{SignLessTypeI32},
-		out: []SignLessType{SignLessTypeF64},
+		in:  []UnsignedType{UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_I64_I32 = &signature{
-		in:  []SignLessType{SignLessTypeI64},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_I64_F32 = &signature{
-		in:  []SignLessType{SignLessTypeI64},
-		out: []SignLessType{SignLessTypeF32},
+		in:  []UnsignedType{UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_I64_F64 = &signature{
-		in:  []SignLessType{SignLessTypeI64},
-		out: []SignLessType{SignLessTypeF64},
+		in:  []UnsignedType{UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_F32_I32 = &signature{
-		in:  []SignLessType{SignLessTypeF32},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_F32_I64 = &signature{
-		in:  []SignLessType{SignLessTypeF32},
-		out: []SignLessType{SignLessTypeI64},
+		in:  []UnsignedType{UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_F32_F64 = &signature{
-		in:  []SignLessType{SignLessTypeF32},
-		out: []SignLessType{SignLessTypeF64},
+		in:  []UnsignedType{UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_F32_F32 = &signature{
-		in:  []SignLessType{SignLessTypeF32},
-		out: []SignLessType{SignLessTypeF32},
+		in:  []UnsignedType{UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_F64_I32 = &signature{
-		in:  []SignLessType{SignLessTypeF64},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_F64_F32 = &signature{
-		in:  []SignLessType{SignLessTypeF64},
-		out: []SignLessType{SignLessTypeF32},
+		in:  []UnsignedType{UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_F64_I64 = &signature{
-		in:  []SignLessType{SignLessTypeF64},
-		out: []SignLessType{SignLessTypeI64},
+		in:  []UnsignedType{UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_F64_F64 = &signature{
-		in:  []SignLessType{SignLessTypeF64},
-		out: []SignLessType{SignLessTypeF64},
+		in:  []UnsignedType{UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_I32I32_None = &signature{
-		in: []SignLessType{SignLessTypeI32, SignLessTypeI32},
+		in: []UnsignedType{UnsignedTypeI32, UnsignedTypeI32},
 	}
 	signature_I32I32_I32 = &signature{
-		in:  []SignLessType{SignLessTypeI32, SignLessTypeI32},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeI32, UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_I32I64_None = &signature{
-		in: []SignLessType{SignLessTypeI32, SignLessTypeI64},
+		in: []UnsignedType{UnsignedTypeI32, UnsignedTypeI64},
 	}
 	signature_I32F32_None = &signature{
-		in: []SignLessType{SignLessTypeI32, SignLessTypeF32},
+		in: []UnsignedType{UnsignedTypeI32, UnsignedTypeF32},
 	}
 	signature_I32F64_None = &signature{
-		in: []SignLessType{SignLessTypeI32, SignLessTypeF64},
+		in: []UnsignedType{UnsignedTypeI32, UnsignedTypeF64},
 	}
 	signature_I64I64_I32 = &signature{
-		in:  []SignLessType{SignLessTypeI64, SignLessTypeI64},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeI64, UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_I64I64_I64 = &signature{
-		in:  []SignLessType{SignLessTypeI64, SignLessTypeI64},
-		out: []SignLessType{SignLessTypeI64},
+		in:  []UnsignedType{UnsignedTypeI64, UnsignedTypeI64},
+		out: []UnsignedType{UnsignedTypeI64},
 	}
 	signature_F32F32_I32 = &signature{
-		in:  []SignLessType{SignLessTypeF32, SignLessTypeF32},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeF32, UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_F32F32_F32 = &signature{
-		in:  []SignLessType{SignLessTypeF32, SignLessTypeF32},
-		out: []SignLessType{SignLessTypeF32},
+		in:  []UnsignedType{UnsignedTypeF32, UnsignedTypeF32},
+		out: []UnsignedType{UnsignedTypeF32},
 	}
 	signature_F64F64_I32 = &signature{
-		in:  []SignLessType{SignLessTypeF64, SignLessTypeF64},
-		out: []SignLessType{SignLessTypeI32},
+		in:  []UnsignedType{UnsignedTypeF64, UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeI32},
 	}
 	signature_F64F64_F64 = &signature{
-		in:  []SignLessType{SignLessTypeF64, SignLessTypeF64},
-		out: []SignLessType{SignLessTypeF64},
+		in:  []UnsignedType{UnsignedTypeF64, UnsignedTypeF64},
+		out: []UnsignedType{UnsignedTypeF64},
 	}
 	signature_UnknownUnkownI32_Unknown = &signature{
-		in:  []SignLessType{SignLessTypeUnknown, SignLessTypeUnknown, SignLessTypeI32},
-		out: []SignLessType{SignLessTypeUnknown},
+		in:  []UnsignedType{UnsignedTypeUnknown, UnsignedTypeUnknown, UnsignedTypeI32},
+		out: []UnsignedType{UnsignedTypeUnknown},
 	}
 )
 
@@ -163,7 +163,7 @@ func wasmOpcodeSignature(f *wasm.FunctionInstance, op wasm.Opcode, index uint32)
 		return funcTypeToSignature(f.ModuleInstance.Functions[index].Signature), nil
 	case wasm.OpcodeCallIndirect:
 		ret := funcTypeToSignature(f.ModuleInstance.Types[index])
-		ret.in = append(ret.in, SignLessTypeI32)
+		ret.in = append(ret.in, UnsignedTypeI32)
 		return ret, nil
 	case wasm.OpcodeDrop:
 		return signature_Unknown_None, nil
@@ -174,50 +174,50 @@ func wasmOpcodeSignature(f *wasm.FunctionInstance, op wasm.Opcode, index uint32)
 		if l := f.NumLocals + inputLen; index >= l {
 			return nil, fmt.Errorf("invalid local index for local.get %d >= %d", index, l)
 		}
-		var t SignLessType
+		var t UnsignedType
 		if index < inputLen {
-			t = WasmValueTypeToSignless(f.Signature.InputTypes[index])
+			t = WasmValueTypeToUnsignedType(f.Signature.InputTypes[index])
 		} else {
-			t = WasmValueTypeToSignless(f.LocalTypes[index-inputLen])
+			t = WasmValueTypeToUnsignedType(f.LocalTypes[index-inputLen])
 		}
-		return &signature{out: []SignLessType{t}}, nil
+		return &signature{out: []UnsignedType{t}}, nil
 	case wasm.OpcodeLocalSet:
 		inputLen := uint32(len(f.Signature.InputTypes))
 		if l := f.NumLocals + inputLen; index >= l {
 			return nil, fmt.Errorf("invalid local index for local.get %d >= %d", index, l)
 		}
-		var t SignLessType
+		var t UnsignedType
 		if index < inputLen {
-			t = WasmValueTypeToSignless(f.Signature.InputTypes[index])
+			t = WasmValueTypeToUnsignedType(f.Signature.InputTypes[index])
 		} else {
-			t = WasmValueTypeToSignless(f.LocalTypes[index-inputLen])
+			t = WasmValueTypeToUnsignedType(f.LocalTypes[index-inputLen])
 		}
-		return &signature{in: []SignLessType{t}}, nil
+		return &signature{in: []UnsignedType{t}}, nil
 	case wasm.OpcodeLocalTee:
 		inputLen := uint32(len(f.Signature.InputTypes))
 		if l := f.NumLocals + inputLen; index >= l {
 			return nil, fmt.Errorf("invalid local index for local.get %d >= %d", index, l)
 		}
-		var t SignLessType
+		var t UnsignedType
 		if index < inputLen {
-			t = WasmValueTypeToSignless(f.Signature.InputTypes[index])
+			t = WasmValueTypeToUnsignedType(f.Signature.InputTypes[index])
 		} else {
-			t = WasmValueTypeToSignless(f.LocalTypes[index-inputLen])
+			t = WasmValueTypeToUnsignedType(f.LocalTypes[index-inputLen])
 		}
-		return &signature{in: []SignLessType{t}, out: []SignLessType{t}}, nil
+		return &signature{in: []UnsignedType{t}, out: []UnsignedType{t}}, nil
 	case wasm.OpcodeGlobalGet:
 		if len(f.ModuleInstance.Globals) <= int(index) {
 			return nil, fmt.Errorf("invalid global index for global.get %d >= %d", index, len(f.ModuleInstance.Globals))
 		}
 		return &signature{
-			out: []SignLessType{WasmValueTypeToSignless(f.ModuleInstance.Globals[index].Type.ValType)},
+			out: []UnsignedType{WasmValueTypeToUnsignedType(f.ModuleInstance.Globals[index].Type.ValType)},
 		}, nil
 	case wasm.OpcodeGlobalSet:
 		if len(f.ModuleInstance.Globals) <= int(index) {
 			return nil, fmt.Errorf("invalid global index for global.get %d >= %d", index, len(f.ModuleInstance.Globals))
 		}
 		return &signature{
-			in: []SignLessType{WasmValueTypeToSignless(f.ModuleInstance.Globals[index].Type.ValType)},
+			in: []UnsignedType{WasmValueTypeToUnsignedType(f.ModuleInstance.Globals[index].Type.ValType)},
 		}, nil
 	case wasm.OpcodeI32Load:
 		return signature_I32_I32, nil
@@ -354,24 +354,24 @@ func wasmOpcodeSignature(f *wasm.FunctionInstance, op wasm.Opcode, index uint32)
 func funcTypeToSignature(tps *wasm.FunctionType) *signature {
 	ret := &signature{}
 	for _, vt := range tps.InputTypes {
-		ret.in = append(ret.in, WasmValueTypeToSignless(vt))
+		ret.in = append(ret.in, WasmValueTypeToUnsignedType(vt))
 	}
 	for _, vt := range tps.ReturnTypes {
-		ret.out = append(ret.out, WasmValueTypeToSignless(vt))
+		ret.out = append(ret.out, WasmValueTypeToUnsignedType(vt))
 	}
 	return ret
 }
 
-func WasmValueTypeToSignless(vt wasm.ValueType) SignLessType {
+func WasmValueTypeToUnsignedType(vt wasm.ValueType) UnsignedType {
 	switch vt {
 	case wasm.ValueTypeI32:
-		return SignLessTypeI32
+		return UnsignedTypeI32
 	case wasm.ValueTypeI64:
-		return SignLessTypeI64
+		return UnsignedTypeI64
 	case wasm.ValueTypeF32:
-		return SignLessTypeF32
+		return UnsignedTypeF32
 	case wasm.ValueTypeF64:
-		return SignLessTypeF64
+		return UnsignedTypeF64
 	}
 	panic("unreachable")
 }


Test patch:
diff --git a/wasm/jit/jit_amd64_test.go b/wasm/jit/jit_amd64_test.go
index 56742735..94fd03e6 100644
--- a/wasm/jit/jit_amd64_test.go
+++ b/wasm/jit/jit_amd64_test.go
@@ -661,7 +661,7 @@ func TestAmd64Builder_handlePick(t *testing.T) {
 	t.Run("on reg", func(t *testing.T) {
 		// Set up the pick target original value.
 		pickTargetLocation := builder.locationStack.pushValueOnRegister(int16(x86.REG_R10))
-		pickTargetLocation.setValueType(wazeroir.SignLessTypeI32)
+		pickTargetLocation.setValueType(wazeroir.UnsignedTypeI32)
 		builder.locationStack.pushValueOnStack() // Dummy value!
 		builder.movIntConstToRegister(100, pickTargetLocation.register)
 		// Now insert pick code.
@@ -759,7 +759,7 @@ func TestAmd64Builder_handleConstI32(t *testing.T) {
 			// To verify the behavior, we increment and push the const value
 			// to the stack.
 			loc := builder.locationStack.peek()
-			require.Equal(t, wazeroir.SignLessTypeI32, loc.valueType)
+			require.Equal(t, wazeroir.UnsignedTypeI32, loc.valueType)
 			prog := builder.newProg()
 			prog.As = x86.AINCQ
 			prog.To.Type = obj.TYPE_REG
@@ -801,7 +801,7 @@ func TestAmd64Builder_handleConstI64(t *testing.T) {
 			// To verify the behavior, we increment and push the const value
 			// to the stack.
 			loc := builder.locationStack.peek()
-			require.Equal(t, wazeroir.SignLessTypeI64, loc.valueType)
+			require.Equal(t, wazeroir.UnsignedTypeI64, loc.valueType)
 			prog := builder.newProg()
 			prog.As = x86.AINCQ
 			prog.To.Type = obj.TYPE_REG
@@ -843,7 +843,7 @@ func TestAmd64Builder_handleConstF32(t *testing.T) {
 			// To verify the behavior, we double and push the const value
 			// to the stack.
 			loc := builder.locationStack.peek()
-			require.Equal(t, wazeroir.SignLessTypeF32, loc.valueType)
+			require.Equal(t, wazeroir.UnsignedTypeF32, loc.valueType)
 			prog := builder.newProg()
 			prog.As = x86.AADDSS
 			prog.To.Type = obj.TYPE_REG
@@ -887,7 +887,7 @@ func TestAmd64Builder_handleConstF64(t *testing.T) {
 			// To verify the behavior, we double and push the const value
 			// to the stack.
 			loc := builder.locationStack.peek()
-			require.Equal(t, wazeroir.SignLessTypeF64, loc.valueType)
+			require.Equal(t, wazeroir.UnsignedTypeF64, loc.valueType)
 			prog := builder.newProg()
 			prog.As = x86.AADDSD
 			prog.To.Type = obj.TYPE_REG
@@ -919,7 +919,7 @@ func TestAmd64Builder_handleConstF64(t *testing.T) {
 
 func TestAmd64Builder_handleAdd(t *testing.T) {
 	t.Run("int64", func(t *testing.T) {
-		o := &wazeroir.OperationAdd{Type: wazeroir.SignLessTypeI64}
+		o := &wazeroir.OperationAdd{Type: wazeroir.UnsignedTypeI64}
 		t.Run("x1:reg,x2:reg", func(t *testing.T) {
 			builder := requireNewBuilder(t)
 			builder.initializeReservedRegisters()
@@ -1071,9 +1071,9 @@ func TestAmd64Builder_handleLe(t *testing.T) {
 		} {
 			var o *wazeroir.OperationLe
 			if tc.signed {
-				o = &wazeroir.OperationLe{Type: wazeroir.SignFulTypeInt32}
+				o = &wazeroir.OperationLe{Type: wazeroir.SignedTypeInt32}
 			} else {
-				o = &wazeroir.OperationLe{Type: wazeroir.SignFulTypeUint32}
+				o = &wazeroir.OperationLe{Type: wazeroir.SignedTypeUint32}
 			}
 			builder := requireNewBuilder(t)
 			builder.initializeReservedRegisters()
@@ -1130,9 +1130,9 @@ func TestAmd64Builder_handleLe(t *testing.T) {
 		} {
 			var o *wazeroir.OperationLe
 			if tc.signed {
-				o = &wazeroir.OperationLe{Type: wazeroir.SignFulTypeInt64}
+				o = &wazeroir.OperationLe{Type: wazeroir.SignedTypeInt64}
 			} else {
-				o = &wazeroir.OperationLe{Type: wazeroir.SignFulTypeUint64}
+				o = &wazeroir.OperationLe{Type: wazeroir.SignedTypeUint64}
 			}
 			builder := requireNewBuilder(t)
 			builder.initializeReservedRegisters()
@@ -1180,7 +1180,7 @@ func TestAmd64Builder_handleLe(t *testing.T) {
 
 func TestAmd64Builder_handleSub(t *testing.T) {
 	t.Run("int64", func(t *testing.T) {
-		o := &wazeroir.OperationSub{Type: wazeroir.SignLessTypeI64}
+		o := &wazeroir.OperationSub{Type: wazeroir.UnsignedTypeI64}
 		t.Run("x1:reg,x2:reg", func(t *testing.T) {
 			builder := requireNewBuilder(t)
 			builder.initializeReservedRegisters()
@@ -1403,11 +1403,11 @@ func TestAmd64Builder_handleCall(t *testing.T) {
 }
 
 func TestAmd64Builder_handleLoad(t *testing.T) {
-	for i, tp := range []wazeroir.SignLessType{
-		wazeroir.SignLessTypeI32,
-		wazeroir.SignLessTypeI64,
-		wazeroir.SignLessTypeF32,
-		wazeroir.SignLessTypeF64,
+	for i, tp := range []wazeroir.UnsignedType{
+		wazeroir.UnsignedTypeI32,
+		wazeroir.UnsignedTypeI64,
+		wazeroir.UnsignedTypeF32,
+		wazeroir.UnsignedTypeF64,
 	} {
 		tp := tp
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
@@ -1432,16 +1432,16 @@ func TestAmd64Builder_handleLoad(t *testing.T) {
 			// Double the loaded value in order to verify the behavior.
 			var addInst obj.As
 			switch tp {
-			case wazeroir.SignLessTypeI32:
+			case wazeroir.UnsignedTypeI32:
 				require.True(t, isIntRegister(loadedValue.register))
 				addInst = x86.AADDL
-			case wazeroir.SignLessTypeI64:
+			case wazeroir.UnsignedTypeI64:
 				require.True(t, isIntRegister(loadedValue.register))
 				addInst = x86.AADDQ
-			case wazeroir.SignLessTypeF32:
+			case wazeroir.UnsignedTypeF32:
 				require.True(t, isFloatRegister(loadedValue.register))
 				addInst = x86.AADDSS
-			case wazeroir.SignLessTypeF64:
+			case wazeroir.UnsignedTypeF64:
 				require.True(t, isFloatRegister(loadedValue.register))
 				addInst = x86.AADDSD
 			}
@@ -1466,19 +1466,19 @@ func TestAmd64Builder_handleLoad(t *testing.T) {
 			targetRegion := mem.Buffer[baseOffset+o.Arg.Offest:]
 			var expValue uint64
 			switch tp {
-			case wazeroir.SignLessTypeI32:
+			case wazeroir.UnsignedTypeI32:
 				original := uint32(100)
 				binary.LittleEndian.PutUint32(targetRegion, original)
 				expValue = uint64(original * 2)
-			case wazeroir.SignLessTypeI64:
+			case wazeroir.UnsignedTypeI64:
 				original := uint64(math.MaxUint32 + 123) // The value exceeds 32-bit.
 				binary.LittleEndian.PutUint64(targetRegion, original)
 				expValue = original * 2
-			case wazeroir.SignLessTypeF32:
+			case wazeroir.UnsignedTypeF32:
 				original := float32(1.234)
 				binary.LittleEndian.PutUint32(targetRegion, math.Float32bits(original))
 				expValue = uint64(math.Float32bits(original * 2))
-			case wazeroir.SignLessTypeF64:
+			case wazeroir.UnsignedTypeF64:
 				original := float64(math.MaxFloat32 + 100.1) // The value exceeds 32-bit.
 				binary.LittleEndian.PutUint64(targetRegion, math.Float64bits(original))
 				expValue = math.Float64bits(original * 2)
@@ -1529,7 +1529,7 @@ func TestAmd64Builder_handleMemorySize(t *testing.T) {
 	builder.handleMemorySize()
 	// At this point, the size of memory should be pushed onto the stack.
 	require.Equal(t, uint64(1), builder.locationStack.sp)
-	require.Equal(t, wazeroir.SignLessTypeI32, builder.locationStack.peek().valueType)
+	require.Equal(t, wazeroir.UnsignedTypeI32, builder.locationStack.peek().valueType)
 
 	// Compile.
 	code, err := builder.compile()