validate: test suite & fixes for validate package

* Refactor validate module to use spec-defined algorithm #143

* Start implementing test suite for validate package

* Disable validate debugging, add doc strings for error types

* Implement more tests for branching, locals, typechecking

* Add tests for call, call_indirect

* Add tests for memory,*_global,*_local

* Add missing validation for unmatched frames at end of function

* Add license header, Errorf -> Fatalf

Author: twitchyliquid64

validate/error.go

@@ -12,6 +12,8 @@ import (
 	ops "github.com/go-interpreter/wagon/wasm/operators"
 )
 
+// Error wraps validation errors with information about where the error
+// was encountered.
 type Error struct {
 	Offset   int // Byte offset in the bytecode vector where the error occurs.
 	Function int // Index into the function index space for the offending function.
@@ -22,53 +24,91 @@ func (e Error) Error() string {
 	return fmt.Sprintf("error while validating function %d at offset %d: %v", e.Function, e.Offset, e.Err)
 }
 
+// ErrStackUnderflow is returned if an instruction consumes a value, but there
+// are no values on the stack.
 var ErrStackUnderflow = errors.New("validate: stack underflow")
 
+// InvalidImmediateError is returned if the immediate value provided
+// is invalid for the given instruction.
 type InvalidImmediateError struct {
 	ImmType string
 	OpName  string
 }
 
 func (e InvalidImmediateError) Error() string {
-	return fmt.Sprintf("invalid immediate for op %s at (should be %s)", e.OpName, e.ImmType)
+	return fmt.Sprintf("invalid immediate for op %s (should be %s)", e.OpName, e.ImmType)
 }
 
+// UnmatchedOpError is returned if a block does not have a corresponding
+// end instruction, or if an else instruction is encountered outside of
+// an if block.
 type UnmatchedOpError byte
 
 func (e UnmatchedOpError) Error() string {
 	n1, _ := ops.New(byte(e))
 	return fmt.Sprintf("encountered unmatched %s", n1.Name)
 }
 
+// InvalidTypeError is returned if a branch is encountered which points to
+// a block that does not exist.
 type InvalidLabelError uint32
 
 func (e InvalidLabelError) Error() string {
 	return fmt.Sprintf("invalid nesting depth %d", uint32(e))
 }
 
+// InvalidTableIndexError is returned if a table is referenced with an
+// out-of-bounds index.
+type InvalidTableIndexError struct {
+	table string
+	index uint32
+}
+
+func (e InvalidTableIndexError) Error() string {
+	return fmt.Sprintf("invalid index %d for %s", e.index, e.table)
+}
+
+// InvalidLocalIndexError is returned if a local variable index is referenced
+// which does not exist.
 type InvalidLocalIndexError uint32
 
 func (e InvalidLocalIndexError) Error() string {
 	return fmt.Sprintf("invalid index for local variable %d", uint32(e))
 }
 
+// InvalidTypeError is returned if there is a mismatch between the type(s)
+// an operator or function accepts, and the value provided.
 type InvalidTypeError struct {
 	Wanted wasm.ValueType
 	Got    wasm.ValueType
 }
 
-func (e InvalidTypeError) Error() string {
-	return fmt.Sprintf("invalid type, got: %v, wanted: %v", e.Got, e.Wanted)
+func valueTypeStr(v wasm.ValueType) string {
+	switch v {
+	case noReturn:
+		return "void"
+	case unknownType:
+		return "anytype"
+	default:
+		return v.String()
+	}
 }
 
-type InvalidElementIndexError uint32
-
-func (e InvalidElementIndexError) Error() string {
-	return fmt.Sprintf("invalid element index %d", uint32(e))
+func (e InvalidTypeError) Error() string {
+	return fmt.Sprintf("invalid type, got: %v, wanted: %v", valueTypeStr(e.Got), valueTypeStr(e.Wanted))
 }
 
+// NoSectionError is returned if a section does not exist.
 type NoSectionError wasm.SectionID
 
 func (e NoSectionError) Error() string {
 	return fmt.Sprintf("reference to non existant section (id %d) in module", wasm.SectionID(e))
 }
+
+// UnbalancedStackErr is returned if there are too many items on the stack
+// than is valid for the current block or function.
+type UnbalancedStackErr wasm.ValueType
+
+func (e UnbalancedStackErr) Error() string {
+	return fmt.Sprintf("unbalanced stack (top of stack is %s)", valueTypeStr(wasm.ValueType(e)))
+}

validate/validate.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// package validate provides functions for validating WebAssembly modules.
+// Package validate provides functions for validating WebAssembly modules.
 package validate
 
 import (
@@ -11,6 +11,7 @@ import (
 	"io"
 
 	"github.com/go-interpreter/wagon/wasm"
+	"github.com/go-interpreter/wagon/wasm/operators"
 	ops "github.com/go-interpreter/wagon/wasm/operators"
 )
 
@@ -23,7 +24,9 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 
 		ctrlFrames: []frame{
 			// The outermost frame is the function itself.
-			{endTypes: fn.ReturnTypes},
+			// endTypes is not populated as function return types
+			// are validated separately.
+			{op: operators.Call},
 		},
 		curFunc: fn,
 	}
@@ -109,17 +112,16 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 			vm.pushFrame(op, frame.endTypes, frame.endTypes)
 
 		case ops.End:
+			// Block 'return' type is validated in popFrame().
 			frame, err := vm.popFrame()
 			if err != nil {
 				return vm, err
 			}
-			if frame == nil {
+			if frame == nil || frame.op == operators.Call {
 				return vm, UnmatchedOpError(op)
 			}
-			for _, ret := range frame.endTypes {
-				if ret != noReturn {
-					vm.pushOperand(ret)
-				}
+			for _, t := range frame.endTypes {
+				vm.pushOperand(t)
 			}
 
 		case ops.Br:
@@ -322,7 +324,7 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 		case ops.I32Load, ops.I64Load, ops.F32Load, ops.F64Load, ops.I32Load8s, ops.I32Load8u, ops.I32Load16s, ops.I32Load16u, ops.I64Load8s, ops.I64Load8u, ops.I64Load16s, ops.I64Load16u, ops.I64Load32s, ops.I64Load32u, ops.I32Store, ops.I64Store, ops.F32Store, ops.F64Store, ops.I32Store8, ops.I32Store16, ops.I64Store8, ops.I64Store16, ops.I64Store32:
 			// read memory_immediate
 			// flags
-			_, err := vm.fetchVarUint()
+			align, err := vm.fetchVarUint()
 			if err != nil {
 				return vm, err
 			}
@@ -332,13 +334,32 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 				return vm, err
 			}
 
+			switch op {
+			case ops.I32Load8s, ops.I32Load8u, ops.I64Load8s, ops.I64Load8u:
+				if align > 1 {
+					return vm, InvalidImmediateError{OpName: opStruct.Name, ImmType: "naturally aligned"}
+				}
+			case ops.I32Load16s, ops.I32Load16u, ops.I64Load16s, ops.I64Load16u:
+				if align > 2 {
+					return vm, InvalidImmediateError{OpName: opStruct.Name, ImmType: "naturally aligned"}
+				}
+			case ops.I32Load, ops.I64Load32s, ops.I64Load32u, ops.F32Load:
+				if align > 4 {
+					return vm, InvalidImmediateError{OpName: opStruct.Name, ImmType: "naturally aligned"}
+				}
+			case ops.I64Load, ops.F64Load:
+				if align > 8 {
+					return vm, InvalidImmediateError{OpName: opStruct.Name, ImmType: "naturally aligned"}
+				}
+			}
+
 		case ops.CurrentMemory, ops.GrowMemory:
 			memIndex, err := vm.fetchByte()
 			if err != nil {
 				return vm, err
 			}
 			if memIndex != 0x00 {
-				return vm, errors.New("validate: memory index must be 0")
+				return vm, InvalidTableIndexError{"memory", uint32(memIndex)}
 			}
 
 		case ops.Call:
@@ -393,7 +414,7 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 				return vm, err
 			}
 			if tableIndex != 0x00 {
-				return vm, errors.New("validate: table index in call_indirect must be 0")
+				return vm, InvalidTableIndexError{"table", uint32(tableIndex)}
 			}
 
 			if index >= uint32(len(module.Types.Entries)) {
@@ -456,6 +477,34 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 		}
 	}
 
+	switch len(fn.ReturnTypes) {
+	case 0:
+		op, err := vm.popOperand()
+		switch {
+		case !vm.topFrameUnreachable() && err == nil:
+			return vm, UnbalancedStackErr(op.Type)
+		case err == ErrStackUnderflow:
+		default:
+			return vm, err
+		}
+	case 1:
+		op, err := vm.popOperand()
+		if err != nil {
+			return vm, err
+		}
+		if !op.Equal(fn.ReturnTypes[0]) {
+			return vm, InvalidTypeError{fn.ReturnTypes[0], op.Type}
+		}
+	}
+
+	f, err := vm.popFrame()
+	if err != nil {
+		return vm, err
+	}
+	if f.op != operators.Call {
+		return vm, UnmatchedOpError(f.op)
+	}
+
 	return vm, nil
 }