Repository: tetratelabs/wazero
Pull request #88 (2021-12-23 08:40:36)

jit: remove 'current' prefixes on engine
per https://github.com/tetratelabs/wazero/pull/86#discussion_r774401112


Patch:
diff --git a/wasm/jit/RATIONALE.md b/wasm/jit/RATIONALE.md
index 8612446f..142e0222 100644
--- a/wasm/jit/RATIONALE.md
+++ b/wasm/jit/RATIONALE.md
@@ -66,8 +66,8 @@ case jitCallStatusCodeCallWasmFunction:
     // Calculate the continuation address so
     // we can resume this caller function frame.
     currentFrame.continuationAddress = currentFrame.f.codeInitialAddress + e.continuationAddressOffset
-    currentFrame.continuationStackPointer = e.currentStackPointer + nextFunc.outputNum - nextFunc.inputNum
-    currentFrame.baseStackPointer = e.currentStackBasePointer
+    currentFrame.continuationStackPointer = e.stackPointer + nextFunc.outputNum - nextFunc.inputNum
+    currentFrame.stackBasePointer = e.stackBasePointer
 ```
 
 and calling into another function in JIT engine's main loop:
@@ -80,7 +80,7 @@ and calling into another function in JIT engine's main loop:
         // Set the caller frame so we can return back to the current frame!
         caller: currentFrame,
         // Set the base pointer to the beginning of the function inputs
-        baseStackPointer: e.currentStackBasePointer + e.currentStackPointer - nextFunc.inputNum,
+        stackBasePointer: e.stackBasePointer + e.stackPointer - nextFunc.inputNum,
     }
 ```
 
@@ -92,8 +92,8 @@ case jitStatusReturned:
     // so we just get back to the caller's frame.
     callerFrame := currentFrame.caller
     e.callFrameStack = callerFrame
-    e.currentStackBasePointer = callerFrame.baseStackPointer
-    e.currentStackPointer = callerFrame.continuationStackPointer
+    e.stackBasePointer = callerFrame.stackBasePointer
+    e.stackPointer = callerFrame.continuationStackPointer
 ```
 
 To summarize, every function call is achieved by returning back to Go code (`engine.exec`'s main loop) with some continuation infor, and enter the callee native code (or host functions) from there. That, of course, comes with a bit of overhead because each function call is implemented by two steps (returning back to `jitcall` callsite AND entering `jitcall` again) vs just `call` instruction (or `jmp`) in usual native codes.
diff --git a/wasm/jit/engine.go b/wasm/jit/engine.go
index f041cde0..e5d6c08e 100644
--- a/wasm/jit/engine.go
+++ b/wasm/jit/engine.go
@@ -17,9 +17,16 @@ type engine struct {
 	// The actual Go-allocated stack.
 	// Note that we NEVER edit len or cap in JITed code so we won't get screwed when GC comes in.
 	stack []uint64
-	// Wasm stack pointer on .stack field which is accessed by currentStackBasePointer+currentStackPointer
-	currentStackPointer     uint64
-	currentStackBasePointer uint64
+	// Stack pointer on .stack field which is accessed by [stackBasePointer] + [stackPointer].
+	stackPointer uint64
+	// stackBasePointer is set whenever we make function calls.
+	// Background: Functions might be compiled as if they use the stack from the bottom,
+	// however in reality, they have to use it from the middle of the stack depending on
+	// when these function calls are made. So instead of accessing stack via stackPointer alone,
+	// functions are compiled so they access the stack via [stackBasePointer](fixed for entire function) + [stackPointer].
+	// More precisely, stackBasePointer is set to [callee's stack pointer] + [callee's stack base pointer] - [caller's inputs].
+	// This way, compiled functions can be independent of the timing of functions calls made against them.
+	stackBasePointer uint64
 	// Where we store the status code of JIT execution.
 	jitCallStatusCode jitCallStatusCode
 	// Set when statusCode == jitStatusCall{Function,BuiltInFunction,HostFunction}
@@ -32,7 +39,7 @@ type engine struct {
 	// restoring reserved registeres.
 	continuationAddressOffset uintptr
 	// The current compiledWasmFunction.globalSliceAddress
-	currentGlobalSliceAddress uintptr
+	globalSliceAddress uintptr
 	// Function call frames in linked list
 	callFrameStack *callFrame
 
@@ -48,13 +55,13 @@ type engine struct {
 
 // Native code manipulates the engine's fields with these constants.
 const (
-	engineStackSliceOffset                = 0
-	engineCurrentStackPointerOffset       = 24
-	engineCurrentStackBasePointerOffset   = 32
-	engineJITCallStatusCodeOffset         = 40
-	engineFunctionCallIndexOffset         = 48
-	engineContinuationAddressOffset       = 56
-	engineCurrentGlobalSliceAddressOffset = 64
+	engineStackSliceOffset          = 0
+	enginestackPointerOffset        = 24
+	enginestackBasePointerOffset    = 32
+	engineJITCallStatusCodeOffset   = 40
+	engineFunctionCallIndexOffset   = 48
+	engineContinuationAddressOffset = 56
+	engineglobalSliceAddressOffset  = 64
 )
 
 func (e *engine) Call(f *wasm.FunctionInstance, args ...uint64) (returns []uint64, err error) {
@@ -218,14 +225,14 @@ func newEngine() *engine {
 }
 
 func (e *engine) pop() (ret uint64) {
-	ret = e.stack[e.currentStackBasePointer+e.currentStackPointer-1]
-	e.currentStackPointer--
+	ret = e.stack[e.stackBasePointer+e.stackPointer-1]
+	e.stackPointer--
 	return
 }
 
 func (e *engine) push(v uint64) {
-	e.stack[e.currentStackBasePointer+e.currentStackPointer] = v
-	e.currentStackPointer++
+	e.stack[e.stackBasePointer+e.stackPointer] = v
+	e.stackPointer++
 }
 
 // jitCallStatusCode represents the result of `jitcall`.
@@ -323,13 +330,13 @@ const (
 // for the next function frame execution.
 func (e *engine) maybeGrowStack(maxStackPointer uint64) {
 	currentLen := uint64(len(e.stack))
-	remained := currentLen - e.currentStackBasePointer
+	remained := currentLen - e.stackBasePointer
 	if maxStackPointer > remained {
 		// This case we need to grow the stack as the empty slots
 		// are not able to store all the stack items.
 		// So we grow the stack with the new len = currentLen*2+maxStackPointer.
 		newStack := make([]uint64, currentLen*2+(maxStackPointer))
-		top := e.currentStackBasePointer + e.currentStackPointer
+		top := e.stackBasePointer + e.stackPointer
 		copy(newStack[:top], e.stack[:top])
 		e.stack = newStack
 	}
@@ -343,15 +350,15 @@ func (e *engine) exec(f *compiledWasmFunction) {
 		caller:                   nil,
 		continuationStackPointer: f.inputs,
 	}
-	e.currentGlobalSliceAddress = f.globalSliceAddress
+	e.globalSliceAddress = f.globalSliceAddress
 	// If the Go-allocated stack is running out, we grow it before calling into JITed code.
 	e.maybeGrowStack(f.maxStackPointer)
 	for e.callFrameStack != nil {
 		currentFrame := e.callFrameStack
 		if buildoptions.IsDebugMode {
-			fmt.Printf("callframe=%s, currentStackBasePointer: %d, currentStackPointer: %d, stack: %v\n",
-				currentFrame.String(), e.currentStackBasePointer, e.currentStackPointer,
-				e.stack[:e.currentStackBasePointer+e.currentStackPointer],
+			fmt.Printf("callframe=%s, stackBasePointer: %d, stackPointer: %d, stack: %v\n",
+				currentFrame.String(), e.stackBasePointer, e.stackPointer,
+				e.stack[:e.stackBasePointer+e.stackPointer],
 			)
 		}
 
@@ -370,8 +377,8 @@ func (e *engine) exec(f *compiledWasmFunction) {
 			callerFrame := currentFrame.caller
 			e.callFrameStack = callerFrame
 			if callerFrame != nil {
-				e.currentStackBasePointer = callerFrame.stackBasePointer
-				e.currentStackPointer = callerFrame.continuationStackPointer
+				e.stackBasePointer = callerFrame.stackBasePointer
+				e.stackPointer = callerFrame.continuationStackPointer
 			}
 		case jitCallStatusCodeCallWasmFunction:
 			// This never panics as we made sure that the index exists for all the referenced functions
@@ -380,8 +387,7 @@ func (e *engine) exec(f *compiledWasmFunction) {
 			// Calculate the continuation address so
 			// we can resume this caller function frame.
 			currentFrame.continuationAddress = currentFrame.wasmFunction.codeInitialAddress + e.continuationAddressOffset
-			currentFrame.continuationStackPointer = e.currentStackPointer + nextFunc.returns - nextFunc.inputs
-			currentFrame.stackBasePointer = e.currentStackBasePointer
+			currentFrame.continuationStackPointer = e.stackPointer + nextFunc.returns - nextFunc.inputs
 			// Create the callee frame.
 			frame := &callFrame{
 				continuationAddress: nextFunc.codeInitialAddress,
@@ -389,16 +395,16 @@ func (e *engine) exec(f *compiledWasmFunction) {
 				// Set the caller frame so we can return back to the current frame!
 				caller: currentFrame,
 				// Set the base pointer to the beginning of the function inputs
-				stackBasePointer: e.currentStackBasePointer + e.currentStackPointer - nextFunc.inputs,
+				stackBasePointer: e.stackBasePointer + e.stackPointer - nextFunc.inputs,
 			}
 			// If the Go-allocated stack is running out, we grow it before calling into JITed code.
 			e.maybeGrowStack(nextFunc.maxStackPointer)
 			// Now move onto the callee function.
 			e.callFrameStack = frame
-			e.currentStackBasePointer = frame.stackBasePointer
+			e.stackBasePointer = frame.stackBasePointer
 			// Set the stack pointer so that base+sp would point to the top of function inputs.
-			e.currentStackPointer = nextFunc.inputs
-			e.currentGlobalSliceAddress = nextFunc.globalSliceAddress
+			e.stackPointer = nextFunc.inputs
+			e.globalSliceAddress = nextFunc.globalSliceAddress
 		case jitCallStatusCodeCallBuiltInFunction:
 			switch e.functionCallIndex {
 			case builtinFunctionIndexMemoryGrow:
diff --git a/wasm/jit/jit_amd64.go b/wasm/jit/jit_amd64.go
index e2ba42ee..5e69a2dd 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))
 	}
 }
 
@@ -291,7 +291,7 @@ func (b *amd64Builder) compile() ([]byte, error) {
 		// Skip MOV, and the register(rax): "0x49, 0xbd"
 		start := obj.Pc + 2
 		// obj.Link = setting offset to memory
-		// obj.Link.Link = writing back the stack pointer to eng.currentStackPointer.
+		// obj.Link.Link = writing back the stack pointer to eng.stackPointer.
 		// obj.Link.Link.Link = Return instruction.
 		// Therefore obj.Link.Link.Link.Link means the next instruction after the return.
 		afterReturnInst := obj.Link.Link.Link.Link
@@ -419,7 +419,7 @@ func (b *amd64Builder) handleGlobalGet(o *wazeroir.OperationGlobalGet) error {
 	moveGlobalSlicePointer.To.Reg = intReg
 	moveGlobalSlicePointer.From.Type = obj.TYPE_MEM
 	moveGlobalSlicePointer.From.Reg = reservedRegisterForEngine
-	moveGlobalSlicePointer.From.Offset = engineCurrentGlobalSliceAddressOffset
+	moveGlobalSlicePointer.From.Offset = engineglobalSliceAddressOffset
 	b.addInstruction(moveGlobalSlicePointer)
 
 	// Then, get the memory location of the target global instance's pointer.
@@ -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
 }
 
@@ -493,7 +493,7 @@ func (b *amd64Builder) handleGlobalSet(o *wazeroir.OperationGlobalSet) error {
 	moveGlobalSlicePointer.To.Reg = intReg
 	moveGlobalSlicePointer.From.Type = obj.TYPE_MEM
 	moveGlobalSlicePointer.From.Reg = reservedRegisterForEngine
-	moveGlobalSlicePointer.From.Offset = engineCurrentGlobalSliceAddressOffset
+	moveGlobalSlicePointer.From.Offset = engineglobalSliceAddressOffset
 	b.addInstruction(moveGlobalSlicePointer)
 
 	// Then, get the memory location of the target global instance's pointer.
@@ -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.
@@ -1592,14 +1592,14 @@ func (b *amd64Builder) assignRegisterToValue(loc *valueLocation, reg int16) {
 }
 
 func (b *amd64Builder) returnFunction() {
-	// Write back the cached SP to the actual eng.currentStackPointer.
+	// Write back the cached SP to the actual eng.stackPointer.
 	prog := b.newProg()
 	prog.As = x86.AMOVQ
 	prog.From.Type = obj.TYPE_CONST
 	prog.From.Offset = int64(b.locationStack.sp)
 	prog.To.Type = obj.TYPE_MEM
 	prog.To.Reg = reservedRegisterForEngine
-	prog.To.Offset = engineCurrentStackPointerOffset
+	prog.To.Offset = enginestackPointerOffset
 	b.addInstruction(prog)
 
 	// Return.
@@ -1610,7 +1610,7 @@ func (b *amd64Builder) returnFunction() {
 
 // initializeReservedRegisters must be called at the very beginning and all the
 // after-call continuations of JITed functions.
-// This caches the actual stack base pointer (engine.currentStackBasePointer*8+[engine.engineStackSliceOffset])
+// This caches the actual stack base pointer (engine.stackBasePointer*8+[engine.engineStackSliceOffset])
 // to cachedStackBasePointerReg
 func (b *amd64Builder) initializeReservedRegisters() {
 	// At first, make cachedStackBasePointerReg point to the beginning of the slice backing array.
@@ -1628,14 +1628,14 @@ func (b *amd64Builder) initializeReservedRegisters() {
 	// or right after function returns so at this point we always have free registers.
 	reg, _ := b.locationStack.takeFreeRegister(generalPurposeRegisterTypeInt)
 
-	// Next we move the base pointer (engine.currentStackBasePointer) to
+	// Next we move the base pointer (engine.stackBasePointer) to
 	// a temporary register.
-	// movq [engineInstanceReg+engineCurrentBaseStackPointerOffset] reg
+	// movq [engineInstanceReg+engineCurrentstackBasePointerOffset] reg
 	prog = b.newProg()
 	prog.As = x86.AMOVQ
 	prog.From.Type = obj.TYPE_MEM
 	prog.From.Reg = reservedRegisterForEngine
-	prog.From.Offset = engineCurrentStackBasePointerOffset
+	prog.From.Offset = enginestackBasePointerOffset
 	prog.To.Type = obj.TYPE_REG
 	prog.To.Reg = reg
 	b.addInstruction(prog)
diff --git a/wasm/jit/jit_value_location_amd64.go b/wasm/jit/jit_value_location_amd64.go
index e04e4aa8..00b7cb09 100644
--- a/wasm/jit/jit_value_location_amd64.go
+++ b/wasm/jit/jit_value_location_amd64.go
@@ -13,7 +13,7 @@ import (
 const (
 	// reservedRegisterForEngine R13: pointer to engine instance (i.e. *engine as uintptr)
 	reservedRegisterForEngine = x86.REG_R13
-	// reservedRegisterForStackBasePointer R14: stack base pointer (engine.currentStackBasePointer) in the current function call.
+	// reservedRegisterForStackBasePointer R14: stack base pointer (engine.stackBasePointer) in the current function call.
 	reservedRegisterForStackBasePointer = x86.REG_R14
 	// reservedRegisterForMemory R15: pointer to memory space (i.e. *[]byte as uintptr).
 	reservedRegisterForMemory = x86.REG_R15
@@ -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/engine_test.go b/wasm/jit/engine_test.go
index 31a18dde..684dcee6 100644
--- a/wasm/jit/engine_test.go
+++ b/wasm/jit/engine_test.go
@@ -15,12 +15,12 @@ import (
 // Ensures that the offset consts do not drift when we manipulate the engine struct.
 func TestEngine_veifyOffsetValue(t *testing.T) {
 	require.Equal(t, int(unsafe.Offsetof((&engine{}).stack)), engineStackSliceOffset)
-	require.Equal(t, int(unsafe.Offsetof((&engine{}).currentStackPointer)), engineCurrentStackPointerOffset)
-	require.Equal(t, int(unsafe.Offsetof((&engine{}).currentStackBasePointer)), engineCurrentStackBasePointerOffset)
+	require.Equal(t, int(unsafe.Offsetof((&engine{}).stackPointer)), enginestackPointerOffset)
+	require.Equal(t, int(unsafe.Offsetof((&engine{}).stackBasePointer)), enginestackBasePointerOffset)
 	require.Equal(t, int(unsafe.Offsetof((&engine{}).jitCallStatusCode)), engineJITCallStatusCodeOffset)
 	require.Equal(t, int(unsafe.Offsetof((&engine{}).functionCallIndex)), engineFunctionCallIndexOffset)
 	require.Equal(t, int(unsafe.Offsetof((&engine{}).continuationAddressOffset)), engineContinuationAddressOffset)
-	require.Equal(t, int(unsafe.Offsetof((&engine{}).currentGlobalSliceAddress)), engineCurrentGlobalSliceAddressOffset)
+	require.Equal(t, int(unsafe.Offsetof((&engine{}).globalSliceAddress)), engineglobalSliceAddressOffset)
 }
 
 func TestEngine_fibonacci(t *testing.T) {
@@ -130,10 +130,10 @@ func TestEngine_PreCompile(t *testing.T) {
 func TestEngine_maybeGrowStack(t *testing.T) {
 	t.Run("grow", func(t *testing.T) {
 		eng := &engine{stack: make([]uint64, 10)}
-		eng.currentStackBasePointer = 5
+		eng.stackBasePointer = 5
 		eng.push(10)
-		require.Equal(t, uint64(1), eng.currentStackPointer)
-		require.Equal(t, uint64(10), eng.stack[eng.currentStackBasePointer+eng.currentStackPointer-1])
+		require.Equal(t, uint64(1), eng.stackPointer)
+		require.Equal(t, uint64(10), eng.stack[eng.stackBasePointer+eng.stackPointer-1])
 		eng.maybeGrowStack(100)
 		// Currently we have 9 empty slots (10 - 1(base pointer)) above base pointer for new items,
 		// but we require 100 max stack pointer for the next function,
@@ -141,21 +141,21 @@ func TestEngine_maybeGrowStack(t *testing.T) {
 		require.Len(t, eng.stack, 120)
 		// maybeAdjustStack only shrink the stack,
 		// and must not modify neither stack pointer nor the values in the stack.
-		require.Equal(t, uint64(1), eng.currentStackPointer)
-		require.Equal(t, uint64(10), eng.stack[eng.currentStackBasePointer+eng.currentStackPointer-1])
+		require.Equal(t, uint64(1), eng.stackPointer)
+		require.Equal(t, uint64(10), eng.stack[eng.stackBasePointer+eng.stackPointer-1])
 	})
 	t.Run("noop", func(t *testing.T) {
 		eng := &engine{stack: make([]uint64, 10)}
-		eng.currentStackBasePointer = 1
+		eng.stackBasePointer = 1
 		eng.push(10)
-		require.Equal(t, uint64(1), eng.currentStackPointer)
-		require.Equal(t, uint64(10), eng.stack[eng.currentStackBasePointer+eng.currentStackPointer-1])
+		require.Equal(t, uint64(1), eng.stackPointer)
+		require.Equal(t, uint64(10), eng.stack[eng.stackBasePointer+eng.stackPointer-1])
 		eng.maybeGrowStack(6)
 		// Currently we have 9 empty slots (10 - 1(base pointer)) above base pointer for new items,
 		// and we only require 6 max stack pointer for the next function, so we have enough empty slots.
 		// so maybeGrowStack must not modify neither stack pointer, the values in the stack nor stack len.
 		require.Len(t, eng.stack, 10)
-		require.Equal(t, uint64(1), eng.currentStackPointer)
-		require.Equal(t, uint64(10), eng.stack[eng.currentStackBasePointer+eng.currentStackPointer-1])
+		require.Equal(t, uint64(1), eng.stackPointer)
+		require.Equal(t, uint64(10), eng.stack[eng.stackBasePointer+eng.stackPointer-1])
 	})
 }
diff --git a/wasm/jit/jit_amd64_test.go b/wasm/jit/jit_amd64_test.go
index 56742735..a1fb7889 100644
--- a/wasm/jit/jit_amd64_test.go
+++ b/wasm/jit/jit_amd64_test.go
@@ -185,7 +185,7 @@ func TestPushValueWithGoroutines(t *testing.T) {
 			eng.exec(f)
 
 			// Because we pushed the value, eng.sp must be incremented by 1
-			if eng.currentStackPointer != 2 {
+			if eng.stackPointer != 2 {
 				panic("eng.sp must be incremented.")
 			}
 
@@ -434,7 +434,7 @@ func TestEngine_exec_callHostFunction(t *testing.T) {
 		eng := newEngine()
 		hostFunction := &compiledHostFunction{
 			f: func(ctx *wasm.HostFunctionCallContext) {
-				eng.stack[eng.currentStackPointer-1] *= 100
+				eng.stack[eng.stackPointer-1] *= 100
 			},
 		}
 		eng.compiledHostFunctions = append(eng.compiledHostFunctions, hostFunction)
@@ -536,19 +536,19 @@ func Test_popFromStackToRegister(t *testing.T) {
 
 	// Call in.
 	eng := newEngine()
-	eng.currentStackBasePointer = 1
-	eng.stack[eng.currentStackBasePointer+2] = 10000
-	eng.stack[eng.currentStackBasePointer+1] = 20000
+	eng.stackBasePointer = 1
+	eng.stack[eng.stackBasePointer+2] = 10000
+	eng.stack[eng.stackBasePointer+1] = 20000
 	mem := newMemoryInst()
-	require.Equal(t, []uint64{0, 20000, 10000}, eng.stack[eng.currentStackBasePointer:eng.currentStackBasePointer+3])
+	require.Equal(t, []uint64{0, 20000, 10000}, eng.stack[eng.stackBasePointer:eng.stackBasePointer+3])
 	jitcall(
 		uintptr(unsafe.Pointer(&code[0])),
 		uintptr(unsafe.Pointer(eng)),
 		uintptr(unsafe.Pointer(&mem.Buffer[0])),
 	)
 	// Check the sp and value.
-	require.Equal(t, uint64(2), eng.currentStackPointer)
-	require.Equal(t, []uint64{0, 30000}, eng.stack[eng.currentStackBasePointer:eng.currentStackBasePointer+eng.currentStackPointer])
+	require.Equal(t, uint64(2), eng.stackPointer)
+	require.Equal(t, []uint64{0, 30000}, eng.stack[eng.stackBasePointer:eng.stackBasePointer+eng.stackPointer])
 }
 
 func TestAmd64Builder_initializeReservedRegisters(t *testing.T) {
@@ -609,7 +609,7 @@ func TestAmd64Builder_allocateRegister(t *testing.T) {
 
 		// Run code.
 		eng := newEngine()
-		eng.currentStackBasePointer = 10
+		eng.stackBasePointer = 10
 		mem := newMemoryInst()
 		jitcall(
 			uintptr(unsafe.Pointer(&code[0])),
@@ -618,8 +618,8 @@ func TestAmd64Builder_allocateRegister(t *testing.T) {
 		)
 
 		// Check the sp and value.
-		require.Equal(t, uint64(2), eng.currentStackPointer)
-		require.Equal(t, []uint64{50, 2000}, eng.stack[eng.currentStackBasePointer:eng.currentStackBasePointer+eng.currentStackPointer])
+		require.Equal(t, uint64(2), eng.stackPointer)
+		require.Equal(t, []uint64{50, 2000}, eng.stack[eng.stackBasePointer:eng.stackBasePointer+eng.stackPointer])
 	})
 }
 
@@ -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.
@@ -695,9 +695,9 @@ func TestAmd64Builder_handlePick(t *testing.T) {
 			uintptr(unsafe.Pointer(&mem.Buffer[0])),
 		)
 		// Check the stack.
-		require.Equal(t, uint64(3), eng.currentStackPointer)
-		require.Equal(t, uint64(101), eng.stack[eng.currentStackPointer-1])
-		require.Equal(t, uint64(100), eng.stack[eng.currentStackPointer-3])
+		require.Equal(t, uint64(3), eng.stackPointer)
+		require.Equal(t, uint64(101), eng.stack[eng.stackPointer-1])
+		require.Equal(t, uint64(100), eng.stack[eng.stackPointer-3])
 	})
 	// The case when the original value is in stack.
 	t.Run("on stack", func(t *testing.T) {
@@ -707,9 +707,9 @@ func TestAmd64Builder_handlePick(t *testing.T) {
 		builder.locationStack.pushValueOnStack() // Dummy value!
 		pickTargetLocation := builder.locationStack.pushValueOnStack()
 		builder.locationStack.pushValueOnStack() // Dummy value!
-		eng.currentStackPointer = 5
-		eng.currentStackBasePointer = 1
-		eng.stack[eng.currentStackBasePointer+pickTargetLocation.stackPointer] = 100
+		eng.stackPointer = 5
+		eng.stackBasePointer = 1
+		eng.stack[eng.stackBasePointer+pickTargetLocation.stackPointer] = 100
 
 		// Now insert pick code.
 		err := builder.handlePick(o)
@@ -739,9 +739,9 @@ func TestAmd64Builder_handlePick(t *testing.T) {
 			uintptr(unsafe.Pointer(&mem.Buffer[0])),
 		)
 		// Check the stack.
-		require.Equal(t, uint64(100), eng.stack[eng.currentStackBasePointer+pickTargetLocation.stackPointer]) // Original value shouldn't be affected.
-		require.Equal(t, uint64(3), eng.currentStackPointer)
-		require.Equal(t, uint64(101), eng.stack[eng.currentStackBasePointer+eng.currentStackPointer-1])
+		require.Equal(t, uint64(100), eng.stack[eng.stackBasePointer+pickTargetLocation.stackPointer]) // Original value shouldn't be affected.
+		require.Equal(t, uint64(3), eng.stackPointer)
+		require.Equal(t, uint64(101), eng.stack[eng.stackBasePointer+eng.stackPointer-1])
 	})
 }
 
@@ -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
@@ -780,9 +780,9 @@ func TestAmd64Builder_handleConstI32(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// As we push the constant to the stack, the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			// Check the value of the top on the stack equals the const plus one.
-			require.Equal(t, uint64(o.Value)+1, eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(o.Value)+1, eng.stack[eng.stackPointer-1])
 		})
 	}
 }
@@ -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
@@ -822,9 +822,9 @@ func TestAmd64Builder_handleConstI64(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// As we push the constant to the stack, the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			// Check the value of the top on the stack equals the const plus one.
-			require.Equal(t, o.Value+1, eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, o.Value+1, eng.stack[eng.stackPointer-1])
 		})
 	}
 }
@@ -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
@@ -866,9 +866,9 @@ func TestAmd64Builder_handleConstF32(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// As we push the constant to the stack, the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			// Check the value of the top on the stack equals the squared const.
-			require.Equal(t, o.Value*2, math.Float32frombits(uint32(eng.stack[eng.currentStackPointer-1])))
+			require.Equal(t, o.Value*2, math.Float32frombits(uint32(eng.stack[eng.stackPointer-1])))
 		})
 	}
 }
@@ -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
@@ -910,16 +910,16 @@ func TestAmd64Builder_handleConstF64(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// As we push the constant to the stack, the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			// Check the value of the top on the stack equals the squared const.
-			require.Equal(t, o.Value*2, math.Float64frombits(eng.stack[eng.currentStackPointer-1]))
+			require.Equal(t, o.Value*2, math.Float64frombits(eng.stack[eng.stackPointer-1]))
 		})
 	}
 }
 
 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()
@@ -951,8 +951,8 @@ func TestAmd64Builder_handleAdd(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
-			require.Equal(t, uint64(400), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(1), eng.stackPointer)
+			require.Equal(t, uint64(400), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:stack,x2:reg", func(t *testing.T) {
 			eng := newEngine()
@@ -982,8 +982,8 @@ func TestAmd64Builder_handleAdd(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(5300), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(5300), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:stack,x2:stack", func(t *testing.T) {
 			eng := newEngine()
@@ -1016,8 +1016,8 @@ func TestAmd64Builder_handleAdd(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(5013), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(5013), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:reg,x2:stack", func(t *testing.T) {
 			eng := newEngine()
@@ -1050,8 +1050,8 @@ func TestAmd64Builder_handleAdd(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(5132), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(5132), eng.stack[eng.stackPointer-1])
 		})
 	})
 }
@@ -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()
@@ -1110,11 +1110,11 @@ func TestAmd64Builder_handleLe(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			if tc.exp {
-				require.Equal(t, uint64(1), eng.stack[eng.currentStackPointer-1])
+				require.Equal(t, uint64(1), eng.stack[eng.stackPointer-1])
 			} else {
-				require.Equal(t, uint64(0), eng.stack[eng.currentStackPointer-1])
+				require.Equal(t, uint64(0), eng.stack[eng.stackPointer-1])
 			}
 		}
 	})
@@ -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()
@@ -1168,11 +1168,11 @@ func TestAmd64Builder_handleLe(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			if tc.exp {
-				require.Equal(t, uint64(1), eng.stack[eng.currentStackPointer-1])
+				require.Equal(t, uint64(1), eng.stack[eng.stackPointer-1])
 			} else {
-				require.Equal(t, uint64(0), eng.stack[eng.currentStackPointer-1])
+				require.Equal(t, uint64(0), eng.stack[eng.stackPointer-1])
 			}
 		}
 	})
@@ -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()
@@ -1212,8 +1212,8 @@ func TestAmd64Builder_handleSub(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
-			require.Equal(t, uint64(249), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(1), eng.stackPointer)
+			require.Equal(t, uint64(249), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:stack,x2:reg", func(t *testing.T) {
 			eng := newEngine()
@@ -1243,8 +1243,8 @@ func TestAmd64Builder_handleSub(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(4700), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(4700), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:stack,x2:stack", func(t *testing.T) {
 			eng := newEngine()
@@ -1277,8 +1277,8 @@ func TestAmd64Builder_handleSub(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(4987), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(4987), eng.stack[eng.stackPointer-1])
 		})
 		t.Run("x1:reg,x2:stack", func(t *testing.T) {
 			eng := newEngine()
@@ -1311,8 +1311,8 @@ func TestAmd64Builder_handleSub(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
-			require.Equal(t, uint64(4868), eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(2), eng.stackPointer)
+			require.Equal(t, uint64(4868), eng.stack[eng.stackPointer-1])
 		})
 	})
 }
@@ -1356,8 +1356,8 @@ func TestAmd64Builder_handleCall(t *testing.T) {
 		require.Equal(t, jitCallStatusCodeCallHostFunction, eng.jitCallStatusCode)
 		require.Equal(t, int64(functionIndex), eng.functionCallIndex)
 		// All the registers must be written back to stack.
-		require.Equal(t, uint64(2), eng.currentStackPointer)
-		require.Equal(t, uint64(50), eng.stack[eng.currentStackPointer-1])
+		require.Equal(t, uint64(2), eng.stackPointer)
+		require.Equal(t, uint64(50), eng.stack[eng.stackPointer-1])
 	})
 	t.Run("wasm function", func(t *testing.T) {
 		const functionIndex = 20
@@ -1397,17 +1397,17 @@ func TestAmd64Builder_handleCall(t *testing.T) {
 		require.Equal(t, jitCallStatusCodeCallWasmFunction, eng.jitCallStatusCode)
 		require.Equal(t, int64(functionIndex), eng.functionCallIndex)
 		// All the registers must be written back to stack.
-		require.Equal(t, uint64(3), eng.currentStackPointer)
-		require.Equal(t, uint64(50), eng.stack[eng.currentStackPointer-1])
+		require.Equal(t, uint64(3), eng.stackPointer)
+		require.Equal(t, uint64(50), eng.stack[eng.stackPointer-1])
 	})
 }
 
 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)
@@ -1493,8 +1493,8 @@ func TestAmd64Builder_handleLoad(t *testing.T) {
 
 			// Load instruction must push the loaded value to the top of the stack,
 			// so the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
-			require.Equal(t, expValue, eng.stack[eng.currentStackPointer-1])
+			require.Equal(t, uint64(1), eng.stackPointer)
+			require.Equal(t, expValue, eng.stack[eng.stackPointer-1])
 		})
 	}
 }
@@ -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()
@@ -1673,11 +1673,11 @@ func TestAmd64Builder_handleDrop(t *testing.T) {
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
 			// Check the stack.
-			require.Equal(t, uint64(2), eng.currentStackPointer)
+			require.Equal(t, uint64(2), eng.stackPointer)
 			require.Equal(t, []uint64{
 				300,
 				5000, // top value should be moved to the dropped position.
-			}, eng.stack[:eng.currentStackPointer])
+			}, eng.stack[:eng.stackPointer])
 		})
 	})
 }
@@ -1714,11 +1714,11 @@ func TestAmd64Builder_releaseAllRegistersToStack(t *testing.T) {
 		uintptr(unsafe.Pointer(&mem.Buffer[0])),
 	)
 	// Check the stack.
-	require.Equal(t, uint64(4), eng.currentStackPointer)
-	require.Equal(t, uint64(123), eng.stack[eng.currentStackPointer-1])
-	require.Equal(t, uint64(51), eng.stack[eng.currentStackPointer-2])
-	require.Equal(t, uint64(300), eng.stack[eng.currentStackPointer-3])
-	require.Equal(t, uint64(100), eng.stack[eng.currentStackPointer-4])
+	require.Equal(t, uint64(4), eng.stackPointer)
+	require.Equal(t, uint64(123), eng.stack[eng.stackPointer-1])
+	require.Equal(t, uint64(51), eng.stack[eng.stackPointer-2])
+	require.Equal(t, uint64(300), eng.stack[eng.stackPointer-3])
+	require.Equal(t, uint64(100), eng.stack[eng.stackPointer-4])
 }
 
 func TestAmd64Builder_assemble(t *testing.T) {
@@ -1886,7 +1886,7 @@ func TestAmd64Builder_handleSelect(t *testing.T) {
 			)
 
 			// Check the selected value.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 			if tc.selectX1 {
 				require.Equal(t, eng.stack[x1.stackPointer], uint64(x1Value))
 			} else {
@@ -1958,7 +1958,7 @@ func TestAmd64Builder_handleSwap(t *testing.T) {
 				uintptr(unsafe.Pointer(eng)),
 				uintptr(unsafe.Pointer(&mem.Buffer[0])),
 			)
-			require.Equal(t, uint64(3), eng.currentStackPointer)
+			require.Equal(t, uint64(3), eng.stackPointer)
 			// Check values are swapped.
 			require.Equal(t, uint64(x1Value), eng.stack[0])
 			require.Equal(t, uint64(x2Value), eng.stack[2])
@@ -2007,7 +2007,7 @@ func TestAmd64Builder_handleGlobalGet(t *testing.T) {
 
 			// Run the code assembled above.
 			eng := newEngine()
-			eng.currentGlobalSliceAddress = uintptr(unsafe.Pointer(&globals[0]))
+			eng.globalSliceAddress = uintptr(unsafe.Pointer(&globals[0]))
 			mem := newMemoryInst()
 			jitcall(
 				uintptr(unsafe.Pointer(&code[0])),
@@ -2017,7 +2017,7 @@ func TestAmd64Builder_handleGlobalGet(t *testing.T) {
 			// Since we call global.get, the top of the stack must be the global value.
 			require.Equal(t, globalValue, eng.stack[0])
 			// Plus as we push the value, the stack pointer must be incremented.
-			require.Equal(t, uint64(1), eng.currentStackPointer)
+			require.Equal(t, uint64(1), eng.stackPointer)
 		})
 	}
 }
@@ -2046,7 +2046,7 @@ func TestAmd64Builder_handleGlobalSet(t *testing.T) {
 			require.NoError(t, err)
 			// Run code.
 			eng := newEngine()
-			eng.currentGlobalSliceAddress = uintptr(unsafe.Pointer(&globals[0]))
+			eng.globalSliceAddress = uintptr(unsafe.Pointer(&globals[0]))
 			eng.push(valueToSet)
 			mem := newMemoryInst()
 			jitcall(
@@ -2057,7 +2057,7 @@ func TestAmd64Builder_handleGlobalSet(t *testing.T) {
 			// The global value should be set to valueToSet.
 			require.Equal(t, valueToSet, globals[op.Index].Val)
 			// Plus we consumed the top of the stack, the stack pointer must be decremented.
-			require.Equal(t, uint64(0), eng.currentStackPointer)
+			require.Equal(t, uint64(0), eng.stackPointer)
 		})
 	}
 }