From 3fcd6935dd8f9624f0f69a9f130464fa4f8d34c1 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Wed, 1 Jun 2016 17:01:26 +0200 Subject: [PATCH 1/9] More func tests --- ml-proto/test/func.wast | 229 ++++++++++++++++++++++++++++++++++ ml-proto/test/functions.wast | 44 ------- ml-proto/test/return.wast | 230 +++++++++++++++++------------------ 3 files changed, 341 insertions(+), 162 deletions(-) create mode 100644 ml-proto/test/func.wast delete mode 100644 ml-proto/test/functions.wast diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast new file mode 100644 index 0000000000..04973b7d6f --- /dev/null +++ b/ml-proto/test/func.wast @@ -0,0 +1,229 @@ +;; Test `func` declarations, i.e. functions + +(module + (func $dummy) + + (func "empty") + (func "value-void" (call $dummy)) + (func "value-drop" (i32.const 1)) + (func "value-i32" (result i32) (i32.const 77)) + (func "value-i64" (result i64) (i64.const 7777)) + (func "value-f32" (result f32) (f32.const 77.7)) + (func "value-f64" (result f64) (f64.const 77.77)) + (func "value-block-void" (block (i32.const 1) (call $dummy))) + (func "value-block-drop" (block (call $dummy) (i32.const 1))) + (func "value-block-i32" (result i32) (block (call $dummy) (i32.const 77))) + + (func "return-nullary" (return)) + (func "return-void" (return (call $dummy))) + (func "return-drop" (return (i32.const 1))) + (func "return-i32" (result i32) (return (i32.const 78))) + (func "return-i64" (result i64) (return (i64.const 7878))) + (func "return-f32" (result f32) (return (f32.const 78.7))) + (func "return-f64" (result f64) (return (f64.const 78.78))) + (func "return-block-void" (return (block (i32.const 1) (call $dummy)))) + (func "return-block-drop" (return (block (call $dummy) (i32.const 1)))) + (func "return-block-i32" (result i32) (return (block (call $dummy) (i32.const 77)))) + + (func "break-nullary" (br 0)) + (func "break-void" (br 0 (call $dummy))) + (func "break-drop" (br 0 (i32.const 1))) + (func "break-i32" (result i32) (br 0 (i32.const 79))) + (func "break-i64" (result i64) (br 0 (i64.const 7979))) + (func "break-f32" (result f32) (br 0 (f32.const 79.9))) + (func "break-f64" (result f64) (br 0 (f64.const 79.79))) + (func "break-block-void" (br 0 (block (i32.const 1) (call $dummy)))) + (func "break-block-drop" (br 0 (block (call $dummy) (i32.const 1)))) + (func "break-block-i32" (result i32) (br 0 (block (call $dummy) (i32.const 77)))) + + (func "param-first-i32" (param i32 i32) (result i32) (get_local 0)) + (func "param-first-i64" (param i64 i64) (result i64) (get_local 0)) + (func "param-first-f32" (param f32 f32) (result f32) (get_local 0)) + (func "param-first-f64" (param i64 i64) (result i64) (get_local 0)) + (func "param-second-i32" (param i32 i32) (result i32) (get_local 1)) + (func "param-second-i64" (param i64 i64) (result i64) (get_local 1)) + (func "param-second-f32" (param f32 f32) (result f32) (get_local 1)) + (func "param-second-f64" (param f64 f64) (result f64) (get_local 1)) + (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) (get_local 4)) + + ;; TODO: param typing, call, call typing, recursion, mutual recursion +) + +(assert_return (invoke "empty")) +(assert_return (invoke "value-void")) +(assert_return (invoke "value-drop")) +(assert_return (invoke "value-i32") (i32.const 77)) +(assert_return (invoke "value-i64") (i64.const 7777)) +(assert_return (invoke "value-f32") (f32.const 77.7)) +(assert_return (invoke "value-f64") (f64.const 77.77)) +(assert_return (invoke "value-block-void")) +(assert_return (invoke "value-block-drop")) +(assert_return (invoke "value-block-i32") (i32.const 77)) + +(assert_return (invoke "return-nullary")) +(assert_return (invoke "return-void")) +(assert_return (invoke "return-drop")) +(assert_return (invoke "return-i32") (i32.const 78)) +(assert_return (invoke "return-i64") (i64.const 7878)) +(assert_return (invoke "return-f32") (f32.const 78.7)) +(assert_return (invoke "return-f64") (f64.const 78.78)) +(assert_return (invoke "return-block-void")) +(assert_return (invoke "return-block-drop")) +(assert_return (invoke "return-block-i32") (i32.const 77)) + +(assert_return (invoke "break-nullary")) +(assert_return (invoke "break-void")) +(assert_return (invoke "break-drop")) +(assert_return (invoke "break-i32") (i32.const 79)) +(assert_return (invoke "break-i64") (i64.const 7979)) +(assert_return (invoke "break-f32") (f32.const 79.9)) +(assert_return (invoke "break-f64") (f64.const 79.79)) +(assert_return (invoke "break-block-void")) +(assert_return (invoke "break-block-drop")) +(assert_return (invoke "break-block-i32") (i32.const 77)) + +(assert_return (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)) +(assert_return (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)) +(assert_return (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)) +(assert_return (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)) +(assert_return (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)) +(assert_return (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)) +(assert_return (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)) +(assert_return (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)) + +(assert_return + (invoke "param-mixed" + (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4) (f64.const 5.5) (i32.const 6) + ) + (f64.const 5.5) +) + +(assert_invalid + (module (func $type-empty-i32 (result i32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-num (result i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result i32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-num-after-return (result i32) + (return (i32.const 1)) (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num-after-return (result i32) + (return (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-num-after-break (result i32) + (br 0 (i32.const 1)) (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num-after-break (result i32) + (br 0 (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-last-void-vs-num (result i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-num (result i32) + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-num (result i32) + (return (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-num (result i32) + (return (i64.const 1)) (return (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-second-num-vs-num (result i32) + (return (i32.const 1)) (return (f64.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-num (result i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-num (result i32) + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-num (result i32) + (br 0 (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-num (result i32) + (br 0 (i64.const 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-second-num-vs-num (result i32) + (br 0 (i32.const 1)) (br 0 (f64.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-void-vs-num (result i32) + (block (br 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-num (result i32) + (block (br 1 (i64.const 1))) (br 0 (i32.const 1)) + )) + "type mismatch" +) + diff --git a/ml-proto/test/functions.wast b/ml-proto/test/functions.wast deleted file mode 100644 index 0510582d1f..0000000000 --- a/ml-proto/test/functions.wast +++ /dev/null @@ -1,44 +0,0 @@ -(module - (func $empty) - (export "empty" $empty) - - (func $result-nop (nop)) - (export "result-nop" $result-nop) - - (func $result-drop (i32.const 1)) - (export "result-drop" $result-drop) - - (func $result-block-nop (block (i32.const 1) (nop))) - (export "result-block-nop" $result-block-nop) - - (func $result-block-drop (block (nop) (i32.const 1))) - (export "result-block-drop" $result-block-drop) - - (func $return (return)) - (export "return" $return) - - (func $return-nop (return (nop))) - (export "return-nop" $return-nop) - - (func $return-drop (return (i32.const 1))) - (export "return-drop" $return-drop) - - (func $return-block-nop (return (block (i32.const 1) (nop)))) - (export "return-block-nop" $return-block-nop) - - (func $return-block-drop (return (block (nop) (i32.const 1)))) - (export "return-block-drop" $return-block-drop) -) - -(assert_return (invoke "empty")) -(assert_return (invoke "result-nop")) -(assert_return (invoke "result-drop")) -(assert_return (invoke "result-block-nop")) -(assert_return (invoke "result-block-drop")) - -(assert_return (invoke "return")) -(assert_return (invoke "return-nop")) -(assert_return (invoke "return-drop")) -(assert_return (invoke "return-block-nop")) -(assert_return (invoke "return-block-drop")) - diff --git a/ml-proto/test/return.wast b/ml-proto/test/return.wast index 1539f0b31d..b5bdb1cb03 100644 --- a/ml-proto/test/return.wast +++ b/ml-proto/test/return.wast @@ -9,180 +9,180 @@ (func "nullary" (return)) (func "unary" (result f64) (return (f64.const 3.1))) - (func "first" (result i32) + (func "as-func-first" (result i32) (return (i32.const 1)) (i32.const 2) ) - (func "mid" (result i32) + (func "as-func-mid" (result i32) (i32.const 1) (return (i32.const 2)) (i32.const 3) ) - (func "last" + (func "as-func-last" (nop) (i32.const 1) (return) ) - (func "value" (result i32) + (func "as-func-value" (result i32) (nop) (i32.const 1) (return (i32.const 3)) ) - (func "block-first" + (func "as-block-first" (block (return) (i32.const 2)) ) - (func "block-mid" + (func "as-block-mid" (block (i32.const 1) (return) (i32.const 2)) ) - (func "block-last" + (func "as-block-last" (block (nop) (i32.const 1) (return)) ) - (func "block-value" (result i32) + (func "as-block-value" (result i32) (block (nop) (i32.const 1) (return (i32.const 2))) ) - (func "loop-first" (result i32) + (func "as-loop-first" (result i32) (loop (return (i32.const 3)) (i32.const 2)) ) - (func "loop-mid" (result i32) + (func "as-loop-mid" (result i32) (loop (i32.const 1) (return (i32.const 4)) (i32.const 2)) ) - (func "loop-last" (result i32) + (func "as-loop-last" (result i32) (loop (nop) (i32.const 1) (return (i32.const 5))) ) - (func "br-value" (result i32) + (func "as-br-value" (result i32) (block (br 0 (return (i32.const 9)))) ) - (func "br_if-cond" + (func "as-br_if-cond" (block (br_if 0 (return))) ) - (func "br_if-value" (result i32) + (func "as-br_if-value" (result i32) (block (br_if 0 (return (i32.const 8)) (i32.const 1)) (i32.const 7)) ) - (func "br_if-value-cond" (result i32) + (func "as-br_if-value-cond" (result i32) (block (br_if 0 (i32.const 6) (return (i32.const 9))) (i32.const 7)) ) - (func "br_table-index" (result i64) + (func "as-br_table-index" (result i64) (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1) ) - (func "br_table-value" (result i32) + (func "as-br_table-value" (result i32) (block (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7)) ) - (func "br_table-value-index" (result i32) + (func "as-br_table-value-index" (result i32) (block (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7)) ) - (func "return-value" (result i64) + (func "as-return-value" (result i64) (return (return (i64.const 7))) ) - (func "if-cond" (result i32) + (func "as-if-cond" (result i32) (if (return (i32.const 2)) (i32.const 0) (i32.const 1)) ) - (func "if-then" (param i32 i32) (result i32) + (func "as-if-then" (param i32 i32) (result i32) (if (get_local 0) (return (i32.const 3)) (get_local 1)) ) - (func "if-else" (param i32 i32) (result i32) + (func "as-if-else" (param i32 i32) (result i32) (if (get_local 0) (get_local 1) (return (i32.const 4))) ) - (func "select-first" (param i32 i32) (result i32) + (func "as-select-first" (param i32 i32) (result i32) (select (return (i32.const 5)) (get_local 0) (get_local 1)) ) - (func "select-second" (param i32 i32) (result i32) + (func "as-select-second" (param i32 i32) (result i32) (select (get_local 0) (return (i32.const 6)) (get_local 1)) ) - (func "select-cond" (result i32) + (func "as-select-cond" (result i32) (select (i32.const 0) (i32.const 1) (return (i32.const 7))) ) (func $f (param i32 i32 i32) (result i32) (i32.const -1)) - (func "call-first" (result i32) + (func "as-call-first" (result i32) (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3)) ) - (func "call-mid" (result i32) + (func "as-call-mid" (result i32) (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3)) ) - (func "call-last" (result i32) + (func "as-call-last" (result i32) (call $f (i32.const 1) (i32.const 2) (return (i32.const 14))) ) (import "spectest" "print" (param i32 i32 i32)) - (func "call_import-first" + (func "as-call_import-first" (call_import 0 (return) (i32.const 2) (i32.const 3)) ) - (func "call_import-mid" + (func "as-call_import-mid" (call_import 0 (i32.const 1) (return) (i32.const 3)) ) - (func "call_import-last" + (func "as-call_import-last" (call_import 0 (i32.const 1) (i32.const 2) (return)) ) (type $sig (func (param i32 i32 i32) (result i32))) (table $f) - (func "call_indirect-func" (result i32) + (func "as-call_indirect-func" (result i32) (call_indirect $sig (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3)) ) - (func "call_indirect-first" (result i32) + (func "as-call_indirect-first" (result i32) (call_indirect $sig (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3)) ) - (func "call_indirect-mid" (result i32) + (func "as-call_indirect-mid" (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3)) ) - (func "call_indirect-last" (result i32) + (func "as-call_indirect-last" (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23))) ) - (func "set_local-value" (result i32) (local f32) + (func "as-set_local-value" (result i32) (local f32) (set_local 0 (return (i32.const 17))) (i32.const -1) ) (memory 1) - (func "load-address" (result f32) + (func "as-load-address" (result f32) (f32.load (return (f32.const 1.7))) ) - (func "loadN-address" (result i64) + (func "as-loadN-address" (result i64) (i64.load8_s (return (i64.const 30))) ) - (func "store-address" (result i32) + (func "as-store-address" (result i32) (f64.store (return (i32.const 30)) (f64.const 7)) (i32.const -1) ) - (func "store-value" (result i32) + (func "as-store-value" (result i32) (i64.store (i32.const 2) (return (i32.const 31))) (i32.const -1) ) - (func "storeN-address" (result i32) + (func "as-storeN-address" (result i32) (i32.store8 (return (i32.const 32)) (i32.const 7)) (i32.const -1) ) - (func "storeN-value" (result i32) + (func "as-storeN-value" (result i32) (i64.store16 (i32.const 2) (return (i32.const 33))) (i32.const -1) ) - (func "unary-operand" (result f32) + (func "as-unary-operand" (result f32) (f32.neg (return (f32.const 3.4))) ) - (func "binary-left" (result i32) + (func "as-binary-left" (result i32) (i32.add (return (i32.const 3)) (i32.const 10)) ) - (func "binary-right" (result i64) + (func "as-binary-right" (result i64) (i64.sub (i64.const 10) (return (i64.const 45))) ) - (func "test-operand" (result i32) + (func "as-test-operand" (result i32) (i32.eqz (return (i32.const 44))) ) - (func "compare-left" (result i32) + (func "as-compare-left" (result i32) (f64.le (return (i32.const 43)) (f64.const 10)) ) - (func "compare-right" (result i32) + (func "as-compare-right" (result i32) (f32.ne (f32.const 10) (return (i32.const 42))) ) - (func "convert-operand" (result i32) + (func "as-convert-operand" (result i32) (i32.wrap/i64 (return (i32.const 41))) ) - (func "grow_memory-size" (result i32) + (func "as-grow_memory-size" (result i32) (grow_memory (return (i32.const 40))) ) ) @@ -195,93 +195,87 @@ (assert_return (invoke "nullary")) (assert_return (invoke "unary") (f64.const 3.1)) -(assert_invalid - (module (func (result f64) (return))) - "type mismatch" -) +(assert_return (invoke "as-func-first") (i32.const 1)) +(assert_return (invoke "as-func-mid") (i32.const 2)) +(assert_return (invoke "as-func-last")) +(assert_return (invoke "as-func-value") (i32.const 3)) -(assert_invalid - (module (func (result f64) (return (i64.const 1)))) - "type mismatch" -) +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) -(assert_invalid - (module (func (result f64) (return (f32.const 1)))) - "type mismatch" -) +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) -(assert_return (invoke "first") (i32.const 1)) -(assert_return (invoke "mid") (i32.const 2)) -(assert_return (invoke "last")) -(assert_return (invoke "value") (i32.const 3)) +(assert_return (invoke "as-br-value") (i32.const 9)) -(assert_return (invoke "block-first")) -(assert_return (invoke "block-mid")) -(assert_return (invoke "block-last")) -(assert_return (invoke "block-value") (i32.const 2)) +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) -(assert_return (invoke "loop-first") (i32.const 3)) -(assert_return (invoke "loop-mid") (i32.const 4)) -(assert_return (invoke "loop-last") (i32.const 5)) +(assert_return (invoke "as-br_table-index") (i64.const 9)) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) -(assert_return (invoke "br-value") (i32.const 9)) +(assert_return (invoke "as-return-value") (i64.const 7)) -(assert_return (invoke "br_if-cond")) -(assert_return (invoke "br_if-value") (i32.const 8)) -(assert_return (invoke "br_if-value-cond") (i32.const 9)) +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) -(assert_return (invoke "br_table-index") (i64.const 9)) -(assert_return (invoke "br_table-value") (i32.const 10)) -(assert_return (invoke "br_table-value-index") (i32.const 11)) +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) -(assert_return (invoke "return-value") (i64.const 7)) +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) -(assert_return (invoke "if-cond") (i32.const 2)) -(assert_return (invoke "if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) -(assert_return (invoke "if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) -(assert_return (invoke "if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) -(assert_return (invoke "if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-call_import-first")) +(assert_return (invoke "as-call_import-mid")) +(assert_return (invoke "as-call_import-last")) -(assert_return (invoke "select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) -(assert_return (invoke "select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) -(assert_return (invoke "select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) -(assert_return (invoke "select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) -(assert_return (invoke "select-cond") (i32.const 7)) +(assert_return (invoke "as-call_indirect-func") (i32.const 20)) +(assert_return (invoke "as-call_indirect-first") (i32.const 21)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 22)) +(assert_return (invoke "as-call_indirect-last") (i32.const 23)) -(assert_return (invoke "call-first") (i32.const 12)) -(assert_return (invoke "call-mid") (i32.const 13)) -(assert_return (invoke "call-last") (i32.const 14)) +(assert_return (invoke "as-set_local-value") (i32.const 17)) -(assert_return (invoke "call_import-first")) -(assert_return (invoke "call_import-mid")) -(assert_return (invoke "call_import-last")) +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) -(assert_return (invoke "call_indirect-func") (i32.const 20)) -(assert_return (invoke "call_indirect-first") (i32.const 21)) -(assert_return (invoke "call_indirect-mid") (i32.const 22)) -(assert_return (invoke "call_indirect-last") (i32.const 23)) +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) -(assert_return (invoke "set_local-value") (i32.const 17)) +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) -(assert_return (invoke "load-address") (f32.const 1.7)) -(assert_return (invoke "loadN-address") (i64.const 30)) +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) -(assert_return (invoke "store-address") (i32.const 30)) -(assert_return (invoke "store-value") (i32.const 31)) -(assert_return (invoke "storeN-address") (i32.const 32)) -(assert_return (invoke "storeN-value") (i32.const 33)) +(assert_return (invoke "as-test-operand") (i32.const 44)) -(assert_return (invoke "unary-operand") (f32.const 3.4)) +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) -(assert_return (invoke "binary-left") (i32.const 3)) -(assert_return (invoke "binary-right") (i64.const 45)) +(assert_return (invoke "as-convert-operand") (i32.const 41)) -(assert_return (invoke "test-operand") (i32.const 44)) +(assert_return (invoke "as-grow_memory-size") (i32.const 40)) -(assert_return (invoke "compare-left") (i32.const 43)) -(assert_return (invoke "compare-right") (i32.const 42)) - -(assert_return (invoke "convert-operand") (i32.const 41)) - -(assert_return (invoke "grow_memory-size") (i32.const 40)) +(assert_invalid + (module (func $type-value-void-vs-num (result f64) (return))) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result f64) (return (i64.const 1)))) + "type mismatch" +) From 65503f7ea7a3a6e06963f55b61ec0fe6dffdf570 Mon Sep 17 00:00:00 2001 From: Andreas Rossberg Date: Thu, 2 Jun 2016 13:50:47 +0200 Subject: [PATCH 2/9] Tests for call --- ml-proto/spec/check.ml | 6 +- ml-proto/spec/eval.ml | 2 +- ml-proto/test/br.wast | 5 +- ml-proto/test/br_if.wast | 4 + ml-proto/test/br_table.wast | 12 ++ ml-proto/test/call.wast | 258 +++++++++++++++++++++++++++ ml-proto/test/func.wast | 136 ++++++++++++-- ml-proto/test/runaway-recursion.wast | 17 -- 8 files changed, 404 insertions(+), 36 deletions(-) create mode 100644 ml-proto/test/call.wast delete mode 100644 ml-proto/test/runaway-recursion.wast diff --git a/ml-proto/spec/check.ml b/ml-proto/spec/check.ml index a74ed444f4..a3a9426a09 100644 --- a/ml-proto/spec/check.ml +++ b/ml-proto/spec/check.ml @@ -26,7 +26,7 @@ type context = } let lookup category list x = - try List.nth list x.it with Failure _ -> + try List.nth list x.it with Failure _ | Invalid_argument _ -> error x.at ("unknown " ^ category ^ " " ^ string_of_int x.it) let type_ types x = lookup "function type" types x @@ -225,9 +225,9 @@ let rec check_expr c et e = check_type out et e.at and check_exprs c ts es at = + require (List.length ts = List.length es) at "arity mismatch"; let ets = List.map (fun x -> Some x) ts in - try List.iter2 (check_expr c) ets es - with Invalid_argument _ -> error at "arity mismatch" + List.iter2 (check_expr c) ets es and check_expr_opt c et eo at = match eo with diff --git a/ml-proto/spec/eval.ml b/ml-proto/spec/eval.ml index d892d74f52..51f465e0f9 100644 --- a/ml-proto/spec/eval.ml +++ b/ml-proto/spec/eval.ml @@ -65,7 +65,7 @@ type config = } let lookup category list x = - try List.nth list x.it with Failure _ -> + try List.nth list x.it with Failure _ | Invalid_argument _ -> Crash.error x.at ("undefined " ^ category ^ " " ^ string_of_int x.it) let type_ c x = lookup "type" c.instance.module_.it.types x diff --git a/ml-proto/test/br.wast b/ml-proto/test/br.wast index b8a6f9390c..b083263af9 100644 --- a/ml-proto/test/br.wast +++ b/ml-proto/test/br.wast @@ -358,8 +358,11 @@ (module (func $unbound-nested-label (block (block (br 5))))) "unknown label" ) +(assert_invalid + (module (func $negative-label (br -1))) + "unknown label" +) (assert_invalid (module (func $large-label (br 0x100000001))) "unknown label" ) - diff --git a/ml-proto/test/br_if.wast b/ml-proto/test/br_if.wast index dfa989e2a3..ba6d174c0e 100644 --- a/ml-proto/test/br_if.wast +++ b/ml-proto/test/br_if.wast @@ -284,6 +284,10 @@ (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1)))))) "unknown label" ) +(assert_invalid + (module (func $negative-label (br_if -1 (i32.const 1)))) + "unknown label" +) (assert_invalid (module (func $large-label (br_if 0x100000001 (i32.const 1)))) "unknown label" diff --git a/ml-proto/test/br_table.wast b/ml-proto/test/br_table.wast index 4378ea4e76..144e893dfe 100644 --- a/ml-proto/test/br_table.wast +++ b/ml-proto/test/br_table.wast @@ -1306,6 +1306,12 @@ )) "unknown label" ) +(assert_invalid + (module (func $negative-label + (block (br_table 0 -1 0 (i32.const 1))) + )) + "unknown label" +) (assert_invalid (module (func $large-label (block (br_table 0 0x100000001 0 (i32.const 1))) @@ -1325,6 +1331,12 @@ )) "unknown label" ) +(assert_invalid + (module (func $negative-label-default + (block (br_table 0 0 -1 (i32.const 1))) + )) + "unknown label" +) (assert_invalid (module (func $large-label-default (block (br_table 0 0 0x100000001 (i32.const 1))) diff --git a/ml-proto/test/call.wast b/ml-proto/test/call.wast new file mode 100644 index 0000000000..35c11070c8 --- /dev/null +++ b/ml-proto/test/call.wast @@ -0,0 +1,258 @@ +;; Test `call` operator + +(module + (func $const-i32 (result i32) (i32.const 0x132)) + (func $const-i64 (result i64) (i64.const 0x164)) + (func $const-f32 (result f32) (f32.const 0xf32)) + (func $const-f64 (result f64) (f64.const 0xf64)) + + (func $id-i32 (param i32) (result i32) (get_local 0)) + (func $id-i64 (param i64) (result i64) (get_local 0)) + (func $id-f32 (param f32) (result f32) (get_local 0)) + (func $id-f64 (param f64) (result f64) (get_local 0)) + + (func $f32-i32 (param f32 i32) (result i32) (get_local 1)) + (func $i32-i64 (param i32 i64) (result i64) (get_local 1)) + (func $f64-f32 (param f64 f32) (result f32) (get_local 1)) + (func $i64-f64 (param i64 f64) (result f64) (get_local 1)) + + ;; Typing + + (func "type-i32" (result i32) (call $const-i32)) + (func "type-i64" (result i64) (call $const-i64)) + (func "type-f32" (result f32) (call $const-f32)) + (func "type-f64" (result f64) (call $const-f64)) + + (func "type-first-i32" (result i32) (call $id-i32 (i32.const 32))) + (func "type-first-i64" (result i64) (call $id-i64 (i64.const 64))) + (func "type-first-f32" (result f32) (call $id-f32 (f32.const 1.32))) + (func "type-first-f64" (result f64) (call $id-f64 (f64.const 1.64))) + + (func "type-second-i32" (result i32) + (call $f32-i32 (f32.const 32.1) (i32.const 32)) + ) + (func "type-second-i64" (result i64) + (call $i32-i64 (i32.const 32) (i64.const 64)) + ) + (func "type-second-f32" (result f32) + (call $f64-f32 (f64.const 64) (f32.const 32)) + ) + (func "type-second-f64" (result f64) + (call $i64-f64 (i64.const 64) (f64.const 64.1)) + ) + + ;; Recursion + + (func "fac" $fac (param i64) (result i64) + (if (i64.eqz (get_local 0)) + (i64.const 1) + (i64.mul (get_local 0) (call $fac (i64.sub (get_local 0) (i64.const 1)))) + ) + ) + + (func "fac-acc" $fac-acc (param i64 i64) (result i64) + (if (i64.eqz (get_local 0)) + (get_local 1) + (call $fac-acc + (i64.sub (get_local 0) (i64.const 1)) + (i64.mul (get_local 0) (get_local 1)) + ) + ) + ) + + (func "fib" $fib (param i64) (result i64) + (if (i64.le_u (get_local 0) (i64.const 1)) + (i64.const 1) + (i64.add + (call $fib (i64.sub (get_local 0) (i64.const 2))) + (call $fib (i64.sub (get_local 0) (i64.const 1))) + ) + ) + ) + + (func "even" $even (param i64) (result i32) + (if (i64.eqz (get_local 0)) + (i32.const 44) + (call $odd (i64.sub (get_local 0) (i64.const 1))) + ) + ) + (func "odd" $odd (param i64) (result i32) + (if (i64.eqz (get_local 0)) + (i32.const 99) + (call $even (i64.sub (get_local 0) (i64.const 1))) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func "runaway" $runaway (call $runaway)) + + (func "mutual-runaway" $mutual-runaway1 (call $mutual-runaway2)) + (func $mutual-runaway2 (call $mutual-runaway1)) +) + +(assert_return (invoke "type-i32") (i32.const 0x132)) +(assert_return (invoke "type-i64") (i64.const 0x164)) +(assert_return (invoke "type-f32") (f32.const 0xf32)) +(assert_return (invoke "type-f64") (f64.const 0xf64)) + +(assert_return (invoke "type-first-i32") (i32.const 32)) +(assert_return (invoke "type-first-i64") (i64.const 64)) +(assert_return (invoke "type-first-f32") (f32.const 1.32)) +(assert_return (invoke "type-first-f64") (f64.const 1.64)) + +(assert_return (invoke "type-second-i32") (i32.const 32)) +(assert_return (invoke "type-second-i64") (i64.const 64)) +(assert_return (invoke "type-second-f32") (f32.const 32)) +(assert_return (invoke "type-second-f64") (f64.const 64.1)) + +(assert_return (invoke "fac" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120)) +(assert_return + (invoke "fac-acc" (i64.const 25) (i64.const 1)) + (i64.const 7034535277573963776) +) + +(assert_return (invoke "fib" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "fib" (i64.const 5)) (i64.const 8)) +(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946)) + +(assert_return (invoke "even" (i64.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i32.const 44)) + +(assert_trap (invoke "runaway") "call stack exhausted") +(assert_trap (invoke "mutual-runaway") "call stack exhausted") + + +;; Invalid typing + +(assert_invalid + (module + (func $type-void-vs-num (i32.eqz (call 1))) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-num-vs-num (i32.eqz (call 1))) + (func (result i64) (i64.const 1)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $arity-0-vs-1 (call 1)) + (func (param i32)) + ) + "arity mismatch" +) +(assert_invalid + (module + (func $arity-0-vs-2 (call 1)) + (func (param f64 i32)) + ) + "arity mismatch" +) +(assert_invalid + (module + (func $arity-1-vs-0 (call 1 (i32.const 1))) + (func) + ) + "arity mismatch" +) +(assert_invalid + (module + (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1))) + (func) + ) + "arity mismatch" +) + +(assert_invalid + (module + (func $arity-nop-first (call 1 (nop) (i32.const 1) (i32.const 2))) + (func (param i32 i32)) + ) + "arity mismatch" +) +(assert_invalid + (module + (func $arity-nop-mid (call 1 (i32.const 1) (nop) (i32.const 2))) + (func (param i32 i32)) + ) + "arity mismatch" +) +(assert_invalid + (module + (func $arity-nop-last (call 1 (i32.const 1) (i32.const 2) (nop))) + (func (param i32 i32)) + ) + "arity mismatch" +) + +(assert_invalid + (module + (func $type-first-void-vs-num (call 1 (nop) (i32.const 1))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-void-vs-num (call 1 (i32.const 1) (nop))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1))) + (func (param i32 f64)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1))) + (func (param f64 i32)) + ) + "type mismatch" +) + + +;; Unbound function + +(assert_invalid + (module (func $unbound-func (call 1))) + "unknown function" +) +(assert_invalid + (module (func $negative-func (call -1))) + "unknown function" +) +(assert_invalid + (module (func $large-func (call 10001232130000))) + "unknown function" +) diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast index 04973b7d6f..8e0d24c3ec 100644 --- a/ml-proto/test/func.wast +++ b/ml-proto/test/func.wast @@ -3,6 +3,8 @@ (module (func $dummy) + ;; Typing of result + (func "empty") (func "value-void" (call $dummy)) (func "value-drop" (i32.const 1)) @@ -23,7 +25,9 @@ (func "return-f64" (result f64) (return (f64.const 78.78))) (func "return-block-void" (return (block (i32.const 1) (call $dummy)))) (func "return-block-drop" (return (block (call $dummy) (i32.const 1)))) - (func "return-block-i32" (result i32) (return (block (call $dummy) (i32.const 77)))) + (func "return-block-i32" (result i32) + (return (block (call $dummy) (i32.const 77))) + ) (func "break-nullary" (br 0)) (func "break-void" (br 0 (call $dummy))) @@ -34,7 +38,40 @@ (func "break-f64" (result f64) (br 0 (f64.const 79.79))) (func "break-block-void" (br 0 (block (i32.const 1) (call $dummy)))) (func "break-block-drop" (br 0 (block (call $dummy) (i32.const 1)))) - (func "break-block-i32" (result i32) (br 0 (block (call $dummy) (i32.const 77)))) + (func "break-block-i32" (result i32) + (br 0 (block (call $dummy) (i32.const 77))) + ) + + (func "break-br_if-nullary" (param i32) + (br_if 0 (get_local 0)) + ) + (func "break-br_if-void" (param i32) + (br_if 0 (call $dummy) (get_local 0)) + ) + (func "break-br_if-num" (param i32) (result i32) + (br_if 0 (i32.const 50) (get_local 0)) (i32.const 51) + ) + + (func "break-br_table-nullary" (param i32) + (br_table 0 0 0 (get_local 0)) + ) + (func "break-br_table-void" (param i32) + (br_table 0 0 (call $dummy) (get_local 0)) + ) + (func "break-br_table-num" (param i32) (result i32) + (br_table 0 0 (i32.const 50) (get_local 0)) (i32.const 51) + ) + (func "break-br_table-nested-nullary" (param i32) + (block (br_table 0 1 0 (get_local 0))) + ) + (func "break-br_table-nested-num" (param i32) (result i32) + (i32.add + (block (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51)) + (i32.const 2) + ) + ) + + ;; Typing of parameters (func "param-first-i32" (param i32 i32) (result i32) (get_local 0)) (func "param-first-i64" (param i64 i64) (result i64) (get_local 0)) @@ -44,9 +81,9 @@ (func "param-second-i64" (param i64 i64) (result i64) (get_local 1)) (func "param-second-f32" (param f32 f32) (result f32) (get_local 1)) (func "param-second-f64" (param f64 f64) (result f64) (get_local 1)) - (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) (get_local 4)) - - ;; TODO: param typing, call, call typing, recursion, mutual recursion + (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) + (get_local 4) + ) ) (assert_return (invoke "empty")) @@ -82,22 +119,78 @@ (assert_return (invoke "break-block-drop")) (assert_return (invoke "break-block-i32") (i32.const 77)) -(assert_return (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)) -(assert_return (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)) -(assert_return (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)) -(assert_return (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)) -(assert_return (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)) -(assert_return (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)) -(assert_return (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)) -(assert_return (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)) +(assert_return + (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) +) +(assert_return + (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) +) +(assert_return + (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) +) +(assert_return + (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) +) +(assert_return + (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) +) +(assert_return + (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) +) +(assert_return + (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) +) +(assert_return + (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) +) (assert_return (invoke "param-mixed" - (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4) (f64.const 5.5) (i32.const 6) + (f32.const 1) (i32.const 2) (i64.const 3) + (i32.const 4) (f64.const 5.5) (i32.const 6) ) (f64.const 5.5) ) +(assert_return (invoke "break-br_if-nullary" (i32.const 0))) +(assert_return (invoke "break-br_if-nullary" (i32.const 2))) +(assert_return (invoke "break-br_if-void" (i32.const 0))) +(assert_return (invoke "break-br_if-void" (i32.const -1))) +(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51)) +(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50)) + +(assert_return (invoke "break-br_table-nullary" (i32.const 0))) +(assert_return (invoke "break-br_table-nullary" (i32.const 1))) +(assert_return (invoke "break-br_table-nullary" (i32.const 5))) +(assert_return (invoke "break-br_table-nullary" (i32.const -1))) +(assert_return (invoke "break-br_table-void" (i32.const 0))) +(assert_return (invoke "break-br_table-void" (i32.const 1))) +(assert_return (invoke "break-br_table-void" (i32.const 2))) +(assert_return (invoke "break-br_table-void" (i32.const -100))) +(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50)) +(assert_return (invoke "break-br_table-nested-nullary" (i32.const 0))) +(assert_return (invoke "break-br_table-nested-nullary" (i32.const 1))) +(assert_return (invoke "break-br_table-nested-nullary" (i32.const 3))) +(assert_return (invoke "break-br_table-nested-nullary" (i32.const -2))) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52) +) + + +;; Invalid typing of result + (assert_invalid (module (func $type-empty-i32 (result i32))) "type mismatch" @@ -227,3 +320,18 @@ "type mismatch" ) + +;; Invalid typing of parameters + +(assert_invalid + (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) diff --git a/ml-proto/test/runaway-recursion.wast b/ml-proto/test/runaway-recursion.wast deleted file mode 100644 index 71bccd425b..0000000000 --- a/ml-proto/test/runaway-recursion.wast +++ /dev/null @@ -1,17 +0,0 @@ -(module - ;; Implementations are required to have every call consume some abstract - ;; resource towards exhausting some abstract finite limit, such that - ;; infinitely recursive testcases reliably trap in finite time. This is - ;; because otherwise applications could come to depend on it on those - ;; implementations and be incompatible with implementations that don't do - ;; it (or don't do it under the same circumstances). - (func (call 0)) - (export "runaway" 0) - - (func $a (call $b)) - (func $b (call $a)) - (export "mutual_runaway" $a) -) - -(assert_trap (invoke "runaway") "call stack exhausted") -(assert_trap (invoke "mutual_runaway") "call stack exhausted") From 172a92dd89e9b240bcd85d1e64da89491cea5efc Mon Sep 17 00:00:00 2001 From: Andreas Rossberg Date: Thu, 2 Jun 2016 19:06:20 +0200 Subject: [PATCH 3/9] call_indirect --- ml-proto/test/call.wast | 1 + ml-proto/test/call_indirect.wast | 318 +++++++++++++++++++++++++++++++ 2 files changed, 319 insertions(+) create mode 100644 ml-proto/test/call_indirect.wast diff --git a/ml-proto/test/call.wast b/ml-proto/test/call.wast index 35c11070c8..b5d301c070 100644 --- a/ml-proto/test/call.wast +++ b/ml-proto/test/call.wast @@ -1,6 +1,7 @@ ;; Test `call` operator (module + ;; Auxiliary definitions (func $const-i32 (result i32) (i32.const 0x132)) (func $const-i64 (result i64) (i64.const 0x164)) (func $const-f32 (result f32) (f32.const 0xf32)) diff --git a/ml-proto/test/call_indirect.wast b/ml-proto/test/call_indirect.wast new file mode 100644 index 0000000000..3c597c5b02 --- /dev/null +++ b/ml-proto/test/call_indirect.wast @@ -0,0 +1,318 @@ +;; Test `call_indirect` operator + +(module + ;; Auxiliary definitions + (type $proc (func)) + (type $out-i32 (func (result i32))) + (type $out-i64 (func (result i64))) + (type $out-f32 (func (result f32))) + (type $out-f64 (func (result f64))) + (type $over-i32 (func (param i32) (result i32))) + (type $over-i64 (func (param i64) (result i64))) + (type $over-f32 (func (param f32) (result f32))) + (type $over-f64 (func (param f64) (result f64))) + (type $f32-i32 (func (param f32 i32) (result i32))) + (type $i32-i64 (func (param i32 i64) (result i64))) + (type $f64-f32 (func (param f64 f32) (result f32))) + (type $i64-f64 (func (param i64 f64) (result f64))) + + (func $const-i32 (type $out-i32) (i32.const 0x132)) + (func $const-i64 (type $out-i64) (i64.const 0x164)) + (func $const-f32 (type $out-f32) (f32.const 0xf32)) + (func $const-f64 (type $out-f64) (f64.const 0xf64)) + + (func $id-i32 (type $over-i32) (get_local 0)) + (func $id-i64 (type $over-i64) (get_local 0)) + (func $id-f32 (type $over-f32) (get_local 0)) + (func $id-f64 (type $over-f64) (get_local 0)) + + (func $f32-i32 (type $f32-i32) (get_local 1)) + (func $i32-i64 (type $i32-i64) (get_local 1)) + (func $f64-f32 (type $f64-f32) (get_local 1)) + (func $i64-f64 (type $i64-f64) (get_local 1)) + + (table + $const-i32 $const-i64 $const-f32 $const-f64 + $id-i32 $id-i64 $id-f32 $id-f64 + $f32-i32 $i32-i64 $f64-f32 $i64-f64 + $fac $fib $even $odd + $runaway $mutual-runaway1 $mutual-runaway2 + ) + + ;; Typing + + (func "type-i32" (result i32) (call_indirect $out-i32 (i32.const 0))) + (func "type-i64" (result i64) (call_indirect $out-i64 (i32.const 1))) + (func "type-f32" (result f32) (call_indirect $out-f32 (i32.const 2))) + (func "type-f64" (result f64) (call_indirect $out-f64 (i32.const 3))) + + (func "type-first-i32" (result i32) + (call_indirect $over-i32 (i32.const 4) (i32.const 32)) + ) + (func "type-first-i64" (result i64) + (call_indirect $over-i64 (i32.const 5) (i64.const 64)) + ) + (func "type-first-f32" (result f32) + (call_indirect $over-f32 (i32.const 6) (f32.const 1.32)) + ) + (func "type-first-f64" (result f64) + (call_indirect $over-f64 (i32.const 7) (f64.const 1.64)) + ) + + (func "type-second-i32" (result i32) + (call_indirect $f32-i32 (i32.const 8) (f32.const 32.1) (i32.const 32)) + ) + (func "type-second-i64" (result i64) + (call_indirect $i32-i64 (i32.const 9) (i32.const 32) (i64.const 64)) + ) + (func "type-second-f32" (result f32) + (call_indirect $f64-f32 (i32.const 10) (f64.const 64) (f32.const 32)) + ) + (func "type-second-f64" (result f64) + (call_indirect $i64-f64 (i32.const 11) (i64.const 64) (f64.const 64.1)) + ) + + ;; TODO: Dispatch, traps + + ;; Recursion + + (func "fac" $fac (param i64) (result i64) + (if (i64.eqz (get_local 0)) + (i64.const 1) + (i64.mul + (get_local 0) + (call_indirect $over-i64 (i32.const 12) + (i64.sub (get_local 0) (i64.const 1)) + ) + ) + ) + ) + + (func "fib" $fib (param i64) (result i64) + (if (i64.le_u (get_local 0) (i64.const 1)) + (i64.const 1) + (i64.add + (call_indirect $over-i64 (i32.const 13) + (i64.sub (get_local 0) (i64.const 2)) + ) + (call_indirect $over-i64 (i32.const 13) + (i64.sub (get_local 0) (i64.const 1)) + ) + ) + ) + ) + + (func "even" $even (param i32) (result i32) + (if (i32.eqz (get_local 0)) + (i32.const 44) + (call_indirect $over-i32 (i32.const 15) + (i32.sub (get_local 0) (i32.const 1)) + ) + ) + ) + (func "odd" $odd (param i32) (result i32) + (if (i32.eqz (get_local 0)) + (i32.const 99) + (call_indirect $over-i32 (i32.const 14) + (i32.sub (get_local 0) (i32.const 1)) + ) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func "runaway" $runaway (call_indirect $proc (i32.const 16))) + + (func "mutual-runaway" $mutual-runaway1 (call_indirect $proc (i32.const 18))) + (func $mutual-runaway2 (call_indirect $proc (i32.const 17))) +) + +(assert_return (invoke "type-i32") (i32.const 0x132)) +(assert_return (invoke "type-i64") (i64.const 0x164)) +(assert_return (invoke "type-f32") (f32.const 0xf32)) +(assert_return (invoke "type-f64") (f64.const 0xf64)) + +(assert_return (invoke "type-first-i32") (i32.const 32)) +(assert_return (invoke "type-first-i64") (i64.const 64)) +(assert_return (invoke "type-first-f32") (f32.const 1.32)) +(assert_return (invoke "type-first-f64") (f64.const 1.64)) + +(assert_return (invoke "type-second-i32") (i32.const 32)) +(assert_return (invoke "type-second-i64") (i64.const 64)) +(assert_return (invoke "type-second-f32") (f32.const 32)) +(assert_return (invoke "type-second-f64") (f64.const 64.1)) + +(assert_return (invoke "fac" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_return (invoke "fib" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fib" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "fib" (i64.const 5)) (i64.const 8)) +(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946)) + +(assert_return (invoke "even" (i32.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i32.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i32.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 77)) (i32.const 44)) + +(assert_trap (invoke "runaway") "call stack exhausted") +(assert_trap (invoke "mutual-runaway") "call stack exhausted") + + +;; Invalid typing + +(assert_invalid + (module + (type (func)) + (func $type-void-vs-num (i32.eqz (call_indirect 0 (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (result i64))) + (func $type-num-vs-num (i32.eqz (call_indirect 0 (i32.const 0)))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (func $arity-0-vs-1 (call_indirect 0 (i32.const 0))) + ) + "arity mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (func $arity-0-vs-2 (call_indirect 0 (i32.const 0))) + ) + "arity mismatch" +) +(assert_invalid + (module + (type (func)) + (func $arity-1-vs-0 (call_indirect 0 (i32.const 0) (i32.const 1))) + ) + "arity mismatch" +) +(assert_invalid + (module + (type (func)) + (func $arity-2-vs-0 + (call_indirect 0 (i32.const 0) (f64.const 2) (i32.const 1)) + ) + ) + "arity mismatch" +) + +(assert_invalid + (module + (type (func (param i32 i32))) + (func $arity-nop-first + (call_indirect 0 (i32.const 0) (nop) (i32.const 1) (i32.const 2)) + ) + ) + "arity mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (func $arity-nop-mid + (call_indirect 0 (i32.const 0) (i32.const 1) (nop) (i32.const 2)) + ) + ) + "arity mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (func $arity-nop-last + (call_indirect 0 (i32.const 0) (i32.const 1) (i32.const 2) (nop)) + ) + ) + "arity mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (func $type-func-void-vs-i32 (call_indirect 0 (nop) (i32.const 1))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32))) + (func $type-func-num-vs-i32 (call_indirect 0 (i64.const 1) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32 i32))) + (func $type-first-void-vs-num + (call_indirect 0 (i32.const 0) (nop) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (func $type-second-void-vs-num + (call_indirect 0 (i32.const 0) (i32.const 1) (nop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 f64))) + (func $type-first-num-vs-num + (call_indirect 0 (i32.const 0) (f64.const 1) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (func $type-second-num-vs-num + (call_indirect 0 (i32.const 0) (i32.const 1) (f64.const 1)) + ) + ) + "type mismatch" +) + + +;; Unbound type + +(assert_invalid + (module (func $unbound-type (call_indirect 1 (i32.const 0)))) + "unknown function type" +) +(assert_invalid + (module (func $negative-type (call_indirect -1 (i32.const 0)))) + "unknown function type" +) +(assert_invalid + (module (func $large-type (call_indirect 10001232130000 (i32.const 0)))) + "unknown function type" +) From 7040608611e5108ca68048da483ca456d6fe33d1 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Fri, 3 Jun 2016 11:42:19 +0200 Subject: [PATCH 4/9] Test dispatch --- ml-proto/test/call_indirect.wast | 22 +++++- ml-proto/test/func.wast | 120 ++++++++++++++++--------------- 2 files changed, 82 insertions(+), 60 deletions(-) diff --git a/ml-proto/test/call_indirect.wast b/ml-proto/test/call_indirect.wast index 3c597c5b02..7e197036f1 100644 --- a/ml-proto/test/call_indirect.wast +++ b/ml-proto/test/call_indirect.wast @@ -46,6 +46,10 @@ (func "type-f32" (result f32) (call_indirect $out-f32 (i32.const 2))) (func "type-f64" (result f64) (call_indirect $out-f64 (i32.const 3))) + (func "type-index" (result i64) + (call_indirect $over-i64 (i32.const 5) (i64.const 100)) + ) + (func "type-first-i32" (result i32) (call_indirect $over-i32 (i32.const 4) (i32.const 32)) ) @@ -72,7 +76,11 @@ (call_indirect $i64-f64 (i32.const 11) (i64.const 64) (f64.const 64.1)) ) - ;; TODO: Dispatch, traps + ;; Dispatch + + (func "dispatch" (param i32 i64) (result i64) + (call_indirect $over-i64 (get_local 0) (get_local 1)) + ) ;; Recursion @@ -139,6 +147,8 @@ (assert_return (invoke "type-f32") (f32.const 0xf32)) (assert_return (invoke "type-f64") (f64.const 0xf64)) +(assert_return (invoke "type-index") (i64.const 100)) + (assert_return (invoke "type-first-i32") (i32.const 32)) (assert_return (invoke "type-first-i64") (i64.const 64)) (assert_return (invoke "type-first-f32") (f32.const 1.32)) @@ -149,6 +159,16 @@ (assert_return (invoke "type-second-f32") (f32.const 32)) (assert_return (invoke "type-second-f64") (f64.const 64.1)) +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5)) +(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120)) +(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8)) +(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call signature mismatch") +(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call signature mismatch") +(assert_trap (invoke "dispatch" (i32.const 20) (i64.const 2)) "undefined table index") +(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined table index") +(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined table index") + (assert_return (invoke "fac" (i64.const 0)) (i64.const 1)) (assert_return (invoke "fac" (i64.const 1)) (i64.const 1)) (assert_return (invoke "fac" (i64.const 5)) (i64.const 120)) diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast index 8e0d24c3ec..c82c053ade 100644 --- a/ml-proto/test/func.wast +++ b/ml-proto/test/func.wast @@ -1,8 +1,23 @@ ;; Test `func` declarations, i.e. functions (module + ;; Auxiliary definition (func $dummy) + ;; Typing of parameters + + (func "param-first-i32" (param i32 i32) (result i32) (get_local 0)) + (func "param-first-i64" (param i64 i64) (result i64) (get_local 0)) + (func "param-first-f32" (param f32 f32) (result f32) (get_local 0)) + (func "param-first-f64" (param i64 i64) (result i64) (get_local 0)) + (func "param-second-i32" (param i32 i32) (result i32) (get_local 1)) + (func "param-second-i64" (param i64 i64) (result i64) (get_local 1)) + (func "param-second-f32" (param f32 f32) (result f32) (get_local 1)) + (func "param-second-f64" (param f64 f64) (result f64) (get_local 1)) + (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) + (get_local 4) + ) + ;; Typing of result (func "empty") @@ -70,20 +85,39 @@ (i32.const 2) ) ) +) - ;; Typing of parameters +(assert_return + (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) +) +(assert_return + (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) +) +(assert_return + (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) +) +(assert_return + (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) +) +(assert_return + (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) +) +(assert_return + (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) +) +(assert_return + (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) +) +(assert_return + (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) +) - (func "param-first-i32" (param i32 i32) (result i32) (get_local 0)) - (func "param-first-i64" (param i64 i64) (result i64) (get_local 0)) - (func "param-first-f32" (param f32 f32) (result f32) (get_local 0)) - (func "param-first-f64" (param i64 i64) (result i64) (get_local 0)) - (func "param-second-i32" (param i32 i32) (result i32) (get_local 1)) - (func "param-second-i64" (param i64 i64) (result i64) (get_local 1)) - (func "param-second-f32" (param f32 f32) (result f32) (get_local 1)) - (func "param-second-f64" (param f64 f64) (result f64) (get_local 1)) - (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) - (get_local 4) +(assert_return + (invoke "param-mixed" + (f32.const 1) (i32.const 2) (i64.const 3) + (i32.const 4) (f64.const 5.5) (i32.const 6) ) + (f64.const 5.5) ) (assert_return (invoke "empty")) @@ -119,39 +153,6 @@ (assert_return (invoke "break-block-drop")) (assert_return (invoke "break-block-i32") (i32.const 77)) -(assert_return - (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) -) -(assert_return - (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) -) -(assert_return - (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) -) -(assert_return - (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) -) -(assert_return - (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) -) -(assert_return - (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) -) -(assert_return - (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) -) -(assert_return - (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) -) - -(assert_return - (invoke "param-mixed" - (f32.const 1) (i32.const 2) (i64.const 3) - (i32.const 4) (f64.const 5.5) (i32.const 6) - ) - (f64.const 5.5) -) - (assert_return (invoke "break-br_if-nullary" (i32.const 0))) (assert_return (invoke "break-br_if-nullary" (i32.const 2))) (assert_return (invoke "break-br_if-void" (i32.const 0))) @@ -189,6 +190,22 @@ ) +;; Invalid typing of parameters + +(assert_invalid + (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) + + ;; Invalid typing of result (assert_invalid @@ -320,18 +337,3 @@ "type mismatch" ) - -;; Invalid typing of parameters - -(assert_invalid - (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0))) - "type mismatch" -) -(assert_invalid - (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0)))) - "type mismatch" -) -(assert_invalid - (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1)))) - "type mismatch" -) From 6bf42644490baa37440a09d26cd4c7b9e1229e27 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Fri, 3 Jun 2016 13:49:11 +0200 Subject: [PATCH 5/9] Test locals --- ml-proto/test/func.wast | 98 +++++++++++++- ml-proto/test/get_local.wast | 159 +++++++++++++++++++++++ ml-proto/test/set_local.wast | 239 +++++++++++++++++++++++++++++++++++ 3 files changed, 494 insertions(+), 2 deletions(-) create mode 100644 ml-proto/test/get_local.wast create mode 100644 ml-proto/test/set_local.wast diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast index c82c053ade..b928ec1940 100644 --- a/ml-proto/test/func.wast +++ b/ml-proto/test/func.wast @@ -4,17 +4,73 @@ ;; Auxiliary definition (func $dummy) + ;; Syntax + + (func) + (func "f") + (func $f) + (func "g" $h) + + (func (local)) + (func (local i32)) + (func (local $x i32)) + (func (local i32 f64 i64)) + (func (local i32) (local f64)) + (func (local i32 f32) (local $x i64) (local) (local i32 f64)) + + (func (param)) + (func (param i32)) + (func (param $x i32)) + (func (param i32 f64 i64)) + (func (param i32) (param f64)) + (func (param i32 f32) (param $x i64) (param) (param i32 f64)) + + (func (result i32) (unreachable)) + + (func + (param i32 f32) (param $x i64) (param) (param i32) + (result i32) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + + ;; Typing of locals + + (func "local-first-i32" (local i32 i32) (result i32) (get_local 0)) + (func "local-first-i64" (local i64 i64) (result i64) (get_local 0)) + (func "local-first-f32" (local f32 f32) (result f32) (get_local 0)) + (func "local-first-f64" (local f64 f64) (result f64) (get_local 0)) + (func "local-second-i32" (local i32 i32) (result i32) (get_local 1)) + (func "local-second-i64" (local i64 i64) (result i64) (get_local 1)) + (func "local-second-f32" (local f32 f32) (result f32) (get_local 1)) + (func "local-second-f64" (local f64 f64) (result f64) (get_local 1)) + (func "local-mixed" (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32) (result f64) + (f32.neg (get_local 0)) + (i32.eqz (get_local 1)) + (i64.eqz (get_local 2)) + (i32.eqz (get_local 3)) + (f64.neg (get_local 4)) + (i32.eqz (get_local 5)) + (get_local 4) + ) + ;; Typing of parameters (func "param-first-i32" (param i32 i32) (result i32) (get_local 0)) (func "param-first-i64" (param i64 i64) (result i64) (get_local 0)) (func "param-first-f32" (param f32 f32) (result f32) (get_local 0)) - (func "param-first-f64" (param i64 i64) (result i64) (get_local 0)) + (func "param-first-f64" (param f64 f64) (result f64) (get_local 0)) (func "param-second-i32" (param i32 i32) (result i32) (get_local 1)) (func "param-second-i64" (param i64 i64) (result i64) (get_local 1)) (func "param-second-f32" (param f32 f32) (result f32) (get_local 1)) (func "param-second-f64" (param f64 f64) (result f64) (get_local 1)) - (func "param-mixed" (param f32 i32 i64 i32 f64 i32) (result f64) + (func "param-mixed" (param f32 i32) (param) (param $x i64) (param i32 f64 i32) (result f64) + (f32.neg (get_local 0)) + (i32.eqz (get_local 1)) + (i64.eqz (get_local 2)) + (i32.eqz (get_local 3)) + (f64.neg (get_local 4)) + (i32.eqz (get_local 5)) (get_local 4) ) @@ -85,8 +141,25 @@ (i32.const 2) ) ) + + ;; Default initialization of locals + + (func "init-local-i32" (local i32) (result i32) (get_local 0)) + (func "init-local-i64" (local i64) (result i64) (get_local 0)) + (func "init-local-f32" (local f32) (result f32) (get_local 0)) + (func "init-local-f64" (local f64) (result f64) (get_local 0)) ) +(assert_return (invoke "local-first-i32") (i32.const 0)) +(assert_return (invoke "local-first-i64") (i64.const 0)) +(assert_return (invoke "local-first-f32") (f32.const 0)) +(assert_return (invoke "local-first-f64") (f64.const 0)) +(assert_return (invoke "local-second-i32") (i32.const 0)) +(assert_return (invoke "local-second-i64") (i64.const 0)) +(assert_return (invoke "local-second-f32") (f32.const 0)) +(assert_return (invoke "local-second-f64") (f64.const 0)) +(assert_return (invoke "local-mixed") (f64.const 0)) + (assert_return (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) ) @@ -189,6 +262,27 @@ (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52) ) +(assert_return (invoke "init-local-i32") (i32.const 0)) +(assert_return (invoke "init-local-i64") (i64.const 0)) +(assert_return (invoke "init-local-f32") (f32.const 0)) +(assert_return (invoke "init-local-f64") (f64.const 0)) + + +;; Invalid typing of locals + +(assert_invalid + (module (func $type-local-num-vs-num (local i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) + ;; Invalid typing of parameters diff --git a/ml-proto/test/get_local.wast b/ml-proto/test/get_local.wast new file mode 100644 index 0000000000..0597ad53c7 --- /dev/null +++ b/ml-proto/test/get_local.wast @@ -0,0 +1,159 @@ +;; Test `get_local` operator + +(module + ;; Typing + + (func "type-local-i32" (local i32) (result i32) (get_local 0)) + (func "type-local-i64" (local i64) (result i64) (get_local 0)) + (func "type-local-f32" (local f32) (result f32) (get_local 0)) + (func "type-local-f64" (local f64) (result f64) (get_local 0)) + + (func "type-param-i32" (param i32) (result i32) (get_local 0)) + (func "type-param-i64" (param i64) (result i64) (get_local 0)) + (func "type-param-f32" (param f32) (result f32) (get_local 0)) + (func "type-param-f64" (param f64) (result f64) (get_local 0)) + + (func "type-mixed" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64) + (i64.eqz (get_local 0)) + (f32.neg (get_local 1)) + (f64.neg (get_local 2)) + (i32.eqz (get_local 3)) + (i32.eqz (get_local 4)) + (f32.neg (get_local 5)) + (i64.eqz (get_local 6)) + (i64.eqz (get_local 7)) + (f64.neg (get_local 8)) + ) + + ;; Reading + + (func "read" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64) + (set_local 5 (f32.const 5.5)) + (set_local 6 (i64.const 6)) + (set_local 8 (f64.const 8)) + (f64.add + (f64.convert_u/i64 (get_local 0)) + (f64.add + (f64.promote/f32 (get_local 1)) + (f64.add + (get_local 2) + (f64.add + (f64.convert_u/i32 (get_local 3)) + (f64.add + (f64.convert_s/i32 (get_local 4)) + (f64.add + (f64.promote/f32 (get_local 5)) + (f64.add + (f64.convert_u/i64 (get_local 6)) + (f64.add + (f64.convert_u/i64 (get_local 7)) + (get_local 8) + ) + ) + ) + ) + ) + ) + ) + ) + ) +) + +(assert_return (invoke "type-local-i32") (i32.const 0)) +(assert_return (invoke "type-local-i64") (i64.const 0)) +(assert_return (invoke "type-local-f32") (f32.const 0)) +(assert_return (invoke "type-local-f64") (f64.const 0)) + +(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3)) +(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4)) +(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5)) + +(assert_return + (invoke "type-mixed" + (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) + (f64.const -0) +) + +(assert_return + (invoke "read" + (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) + (f64.const 34.8) +) + + +;; Invalid typing of access to locals + +(assert_invalid + (module (func $type-local-num-vs-num (local i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) + + +;; Invalid typing of access to parameters + +(assert_invalid + (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) + + +;; Invalid local index + +(assert_invalid + (module (func $unbound-local (local i32 i64) (get_local 3))) + "unknown local" +) +(assert_invalid + (module (func $negative-local (local i32 i64) (get_local -1))) + "unknown local" +) +(assert_invalid + (module (func $large-local (local i32 i64) (get_local 14324343))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-param (param i32 i64) (get_local 2))) + "unknown local" +) +(assert_invalid + (module (func $negative-param (param i32 i64) (get_local -2))) + "unknown local" +) +(assert_invalid + (module (func $large-param (local i32 i64) (get_local 714324343))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3))) + "unknown local" +) +(assert_invalid + (module (func $negative-mixed (param f32 f64) (local i32 i64) (get_local -1))) + "unknown local" +) +(assert_invalid + (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343))) + "unknown local" +) + diff --git a/ml-proto/test/set_local.wast b/ml-proto/test/set_local.wast new file mode 100644 index 0000000000..2cc5d95263 --- /dev/null +++ b/ml-proto/test/set_local.wast @@ -0,0 +1,239 @@ +;; Test `set_local` operator + +(module + ;; Typing + + (func "type-local-i32" (local i32) (result i32) (set_local 0 (i32.const 0))) + (func "type-local-i64" (local i64) (result i64) (set_local 0 (i64.const 0))) + (func "type-local-f32" (local f32) (result f32) (set_local 0 (f32.const 0))) + (func "type-local-f64" (local f64) (result f64) (set_local 0 (f64.const 0))) + + (func "type-param-i32" (param i32) (result i32) (set_local 0 (i32.const 10))) + (func "type-param-i64" (param i64) (result i64) (set_local 0 (i64.const 11))) + (func "type-param-f32" (param f32) (result f32) (set_local 0 (f32.const 11.1))) + (func "type-param-f64" (param f64) (result f64) (set_local 0 (f64.const 12.2))) + + (func "type-mixed" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) + (i64.eqz (set_local 0 (i64.const 0))) + (f32.neg (set_local 1 (f32.const 0))) + (f64.neg (set_local 2 (f64.const 0))) + (i32.eqz (set_local 3 (i32.const 0))) + (i32.eqz (set_local 4 (i32.const 0))) + (f32.neg (set_local 5 (f32.const 0))) + (i64.eqz (set_local 6 (i64.const 0))) + (i64.eqz (set_local 7 (i64.const 0))) + (f64.neg (set_local 8 (f64.const 0))) + ) + + ;; Writing + + (func "write" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result i64) + (set_local 1 (f32.const -0.3)) + (set_local 3 (i32.const 40)) + (set_local 4 (i32.const -7)) + (set_local 5 (f32.const 5.5)) + (set_local 6 (i64.const 6)) + (set_local 8 (f64.const 8)) + (i64.trunc_s/f64 + (f64.add + (f64.convert_u/i64 (get_local 0)) + (f64.add + (f64.promote/f32 (get_local 1)) + (f64.add + (get_local 2) + (f64.add + (f64.convert_u/i32 (get_local 3)) + (f64.add + (f64.convert_s/i32 (get_local 4)) + (f64.add + (f64.promote/f32 (get_local 5)) + (f64.add + (f64.convert_u/i64 (get_local 6)) + (f64.add + (f64.convert_u/i64 (get_local 7)) + (get_local 8) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + ;; Result + + (func "result" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64) + (f64.add + (f64.convert_u/i64 (set_local 0 (i64.const 1))) + (f64.add + (f64.promote/f32 (set_local 1 (f32.const 2))) + (f64.add + (set_local 2 (f64.const 3.3)) + (f64.add + (f64.convert_u/i32 (set_local 3 (i32.const 4))) + (f64.add + (f64.convert_s/i32 (set_local 4 (i32.const 5))) + (f64.add + (f64.promote/f32 (set_local 5 (f32.const 5.5))) + (f64.add + (f64.convert_u/i64 (set_local 6 (i64.const 6))) + (f64.add + (f64.convert_u/i64 (set_local 7 (i64.const 0))) + (set_local 8 (f64.const 8)) + ) + ) + ) + ) + ) + ) + ) + ) + ) +) + +(assert_return (invoke "type-local-i32") (i32.const 0)) +(assert_return (invoke "type-local-i64") (i64.const 0)) +(assert_return (invoke "type-local-f32") (f32.const 0)) +(assert_return (invoke "type-local-f64") (f64.const 0)) + +(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10)) +(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11)) +(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1)) +(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2)) + +(assert_return + (invoke "type-mixed" + (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) +) + +(assert_return + (invoke "write" + (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5) + ) + (i64.const 56) +) + +(assert_return + (invoke "result" + (i64.const -1) (f32.const -2) (f64.const -3.3) (i32.const -4) (i32.const -5) + ) + (f64.const 34.8) +) + + +;; Invalid typing of access to locals + +(assert_invalid + (module (func $type-local-num-vs-num (local i32) (result i64) (set_local 0 (i32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (set_local 0 (f32.const 0))))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (set_local 1 (i64.const 0))))) + "type mismatch" +) + +(assert_invalid + (module (func $type-local-arg-num-vs-num (local i32) (set_local 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f32) (set_local 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-arg-num-vs-num (local f64 i64) (set_local 1 (f64.const 0)))) + "type mismatch" +) + + +;; Invalid typing of access to parameters + +(assert_invalid + (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-arg-num-vs-num (param i32) (set_local 0 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f32) (set_local 0 (f64.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-param-arg-num-vs-num (param f64 i64) (set_local 1 (f64.const 0)))) + "type mismatch" +) + + +;; Invalid local index + +(assert_invalid + (module (func $unbound-local (local i32 i64) (get_local 3))) + "unknown local" +) +(assert_invalid + (module (func $negative-local (local i32 i64) (get_local -1))) + "unknown local" +) +(assert_invalid + (module (func $large-local (local i32 i64) (get_local 14324343))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-param (param i32 i64) (get_local 2))) + "unknown local" +) +(assert_invalid + (module (func $negative-param (param i32 i64) (get_local -2))) + "unknown local" +) +(assert_invalid + (module (func $large-param (local i32 i64) (get_local 714324343))) + "unknown local" +) + +(assert_invalid + (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3))) + "unknown local" +) +(assert_invalid + (module (func $negative-mixed (param f32 f64) (local i32 i64) (get_local -1))) + "unknown local" +) +(assert_invalid + (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343))) + "unknown local" +) + +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (set_local 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (set_local 1 (f32.const 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (set_local 1 (i64.const 0)))) + "type mismatch" +) + From 0b44b0a4e0f62a08b4f114a8955414ce9e285378 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Fri, 3 Jun 2016 13:52:04 +0200 Subject: [PATCH 6/9] Func signature syntax --- ml-proto/test/func.wast | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast index b928ec1940..c79012bd97 100644 --- a/ml-proto/test/func.wast +++ b/ml-proto/test/func.wast @@ -2,6 +2,7 @@ (module ;; Auxiliary definition + (type $sig (func)) (func $dummy) ;; Syntax @@ -27,12 +28,20 @@ (func (result i32) (unreachable)) - (func + (func (type $sig)) + + (func $complex (param i32 f32) (param $x i64) (param) (param i32) (result i32) (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) (unreachable) (unreachable) ) + (func $complex-sig + (type $sig) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + ;; Typing of locals From b6bc94656d69d306ee307c5bfcd9d0c90a460a6f Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Fri, 3 Jun 2016 14:16:52 +0200 Subject: [PATCH 7/9] Syntactically disallow signs for uints --- ml-proto/host/lexer.mll | 24 +++++++++++++----------- ml-proto/host/parser.mly | 12 +++++++----- ml-proto/test/br.wast | 4 ---- ml-proto/test/br_if.wast | 4 ---- ml-proto/test/br_table.wast | 12 ------------ ml-proto/test/call.wast | 4 ---- ml-proto/test/call_indirect.wast | 4 ---- ml-proto/test/get_local.wast | 12 ------------ ml-proto/test/set_local.wast | 12 ------------ 9 files changed, 20 insertions(+), 68 deletions(-) diff --git a/ml-proto/host/lexer.mll b/ml-proto/host/lexer.mll index 4774d41d93..61b4d62f7d 100644 --- a/ml-proto/host/lexer.mll +++ b/ml-proto/host/lexer.mll @@ -88,18 +88,19 @@ let escape = ['n''t''\\''\'''\"'] let character = [^'"''\\''\x00'-'\x1f''\x7f'] | '\\'escape | '\\'hexdigit hexdigit -let sign = ('+' | '-')? -let num = sign digit+ -let hexnum = sign "0x" hexdigit+ -let int = num | hexnum +let sign = ('+' | '-') +let num = digit+ +let hexnum = "0x" hexdigit+ +let nat = num | hexnum +let int = sign nat let float = - (num '.' digit*) - | num ('.' digit*)? ('e' | 'E') num - | sign "0x" hexdigit+ '.'? hexdigit* 'p' sign digit+ - | sign "inf" - | sign "infinity" - | sign "nan" - | sign "nan:0x" hexdigit+ + sign? num '.' digit* + | sign? num ('.' digit*)? ('e' | 'E') sign? num + | sign? "0x" hexdigit+ '.'? hexdigit* 'p' sign? digit+ + | sign? "inf" + | sign? "infinity" + | sign? "nan" + | sign? "nan:0x" hexdigit+ let text = '"' character* '"' let name = '$' (letter | digit | '_' | tick | symbol)+ @@ -115,6 +116,7 @@ let mem_size = "8" | "16" | "32" rule token = parse | "(" { LPAR } | ")" { RPAR } + | nat as s { NAT s } | int as s { INT s } | float as s { FLOAT s } | text as s { TEXT (text s) } diff --git a/ml-proto/host/parser.mly b/ml-proto/host/parser.mly index c79b54fe6f..25f50b14fd 100644 --- a/ml-proto/host/parser.mly +++ b/ml-proto/host/parser.mly @@ -124,7 +124,7 @@ let implicit_decl c t at = %} -%token INT FLOAT TEXT VAR VALUE_TYPE LPAR RPAR +%token NAT INT FLOAT TEXT VAR VALUE_TYPE LPAR RPAR %token NOP BLOCK IF THEN ELSE SELECT LOOP BR BR_IF BR_TABLE %token CALL CALL_IMPORT CALL_INDIRECT RETURN %token GET_LOCAL SET_LOCAL LOAD STORE OFFSET ALIGN @@ -136,6 +136,7 @@ let implicit_decl c t at = %token INPUT OUTPUT %token EOF +%token NAT %token INT %token FLOAT %token TEXT @@ -190,12 +191,13 @@ func_type : /* Expressions */ literal : + | NAT { $1 @@ at () } | INT { $1 @@ at () } | FLOAT { $1 @@ at () } ; var : - | INT { let at = at () in fun c lookup -> int_of_string $1 @@ at } + | NAT { let at = at () in fun c lookup -> int_of_string $1 @@ at } | VAR { let at = at () in fun c lookup -> lookup c ($1 @@ at) @@ at } ; var_list : @@ -345,7 +347,7 @@ start : { fun c -> $3 c func } segment : - | LPAR SEGMENT INT text_list RPAR + | LPAR SEGMENT NAT text_list RPAR { {Memory.addr = Int64.of_string $3; Memory.data = $4} @@ at () } ; segment_list : @@ -354,10 +356,10 @@ segment_list : ; memory : - | LPAR MEMORY INT INT segment_list RPAR + | LPAR MEMORY NAT NAT segment_list RPAR { {min = Int64.of_string $3; max = Int64.of_string $4; segments = $5} @@ at () } - | LPAR MEMORY INT segment_list RPAR + | LPAR MEMORY NAT segment_list RPAR { {min = Int64.of_string $3; max = Int64.of_string $3; segments = $4} @@ at () } ; diff --git a/ml-proto/test/br.wast b/ml-proto/test/br.wast index b083263af9..a370f88af7 100644 --- a/ml-proto/test/br.wast +++ b/ml-proto/test/br.wast @@ -358,10 +358,6 @@ (module (func $unbound-nested-label (block (block (br 5))))) "unknown label" ) -(assert_invalid - (module (func $negative-label (br -1))) - "unknown label" -) (assert_invalid (module (func $large-label (br 0x100000001))) "unknown label" diff --git a/ml-proto/test/br_if.wast b/ml-proto/test/br_if.wast index ba6d174c0e..dfa989e2a3 100644 --- a/ml-proto/test/br_if.wast +++ b/ml-proto/test/br_if.wast @@ -284,10 +284,6 @@ (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1)))))) "unknown label" ) -(assert_invalid - (module (func $negative-label (br_if -1 (i32.const 1)))) - "unknown label" -) (assert_invalid (module (func $large-label (br_if 0x100000001 (i32.const 1)))) "unknown label" diff --git a/ml-proto/test/br_table.wast b/ml-proto/test/br_table.wast index 144e893dfe..4378ea4e76 100644 --- a/ml-proto/test/br_table.wast +++ b/ml-proto/test/br_table.wast @@ -1306,12 +1306,6 @@ )) "unknown label" ) -(assert_invalid - (module (func $negative-label - (block (br_table 0 -1 0 (i32.const 1))) - )) - "unknown label" -) (assert_invalid (module (func $large-label (block (br_table 0 0x100000001 0 (i32.const 1))) @@ -1331,12 +1325,6 @@ )) "unknown label" ) -(assert_invalid - (module (func $negative-label-default - (block (br_table 0 0 -1 (i32.const 1))) - )) - "unknown label" -) (assert_invalid (module (func $large-label-default (block (br_table 0 0 0x100000001 (i32.const 1))) diff --git a/ml-proto/test/call.wast b/ml-proto/test/call.wast index b5d301c070..b903a8d056 100644 --- a/ml-proto/test/call.wast +++ b/ml-proto/test/call.wast @@ -249,10 +249,6 @@ (module (func $unbound-func (call 1))) "unknown function" ) -(assert_invalid - (module (func $negative-func (call -1))) - "unknown function" -) (assert_invalid (module (func $large-func (call 10001232130000))) "unknown function" diff --git a/ml-proto/test/call_indirect.wast b/ml-proto/test/call_indirect.wast index 7e197036f1..cf71b54e43 100644 --- a/ml-proto/test/call_indirect.wast +++ b/ml-proto/test/call_indirect.wast @@ -328,10 +328,6 @@ (module (func $unbound-type (call_indirect 1 (i32.const 0)))) "unknown function type" ) -(assert_invalid - (module (func $negative-type (call_indirect -1 (i32.const 0)))) - "unknown function type" -) (assert_invalid (module (func $large-type (call_indirect 10001232130000 (i32.const 0)))) "unknown function type" diff --git a/ml-proto/test/get_local.wast b/ml-proto/test/get_local.wast index 0597ad53c7..e2549dd149 100644 --- a/ml-proto/test/get_local.wast +++ b/ml-proto/test/get_local.wast @@ -122,10 +122,6 @@ (module (func $unbound-local (local i32 i64) (get_local 3))) "unknown local" ) -(assert_invalid - (module (func $negative-local (local i32 i64) (get_local -1))) - "unknown local" -) (assert_invalid (module (func $large-local (local i32 i64) (get_local 14324343))) "unknown local" @@ -135,10 +131,6 @@ (module (func $unbound-param (param i32 i64) (get_local 2))) "unknown local" ) -(assert_invalid - (module (func $negative-param (param i32 i64) (get_local -2))) - "unknown local" -) (assert_invalid (module (func $large-param (local i32 i64) (get_local 714324343))) "unknown local" @@ -148,10 +140,6 @@ (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3))) "unknown local" ) -(assert_invalid - (module (func $negative-mixed (param f32 f64) (local i32 i64) (get_local -1))) - "unknown local" -) (assert_invalid (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343))) "unknown local" diff --git a/ml-proto/test/set_local.wast b/ml-proto/test/set_local.wast index 2cc5d95263..bbc1d591cb 100644 --- a/ml-proto/test/set_local.wast +++ b/ml-proto/test/set_local.wast @@ -189,10 +189,6 @@ (module (func $unbound-local (local i32 i64) (get_local 3))) "unknown local" ) -(assert_invalid - (module (func $negative-local (local i32 i64) (get_local -1))) - "unknown local" -) (assert_invalid (module (func $large-local (local i32 i64) (get_local 14324343))) "unknown local" @@ -202,10 +198,6 @@ (module (func $unbound-param (param i32 i64) (get_local 2))) "unknown local" ) -(assert_invalid - (module (func $negative-param (param i32 i64) (get_local -2))) - "unknown local" -) (assert_invalid (module (func $large-param (local i32 i64) (get_local 714324343))) "unknown local" @@ -215,10 +207,6 @@ (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3))) "unknown local" ) -(assert_invalid - (module (func $negative-mixed (param f32 f64) (local i32 i64) (get_local -1))) - "unknown local" -) (assert_invalid (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343))) "unknown local" From e2e6680e84e6cbc682beaee555b7165da139cfac Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Fri, 3 Jun 2016 14:24:35 +0200 Subject: [PATCH 8/9] Some more checks --- ml-proto/test/set_local.wast | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/ml-proto/test/set_local.wast b/ml-proto/test/set_local.wast index bbc1d591cb..e93960d9ea 100644 --- a/ml-proto/test/set_local.wast +++ b/ml-proto/test/set_local.wast @@ -140,6 +140,10 @@ "type mismatch" ) +(assert_invalid + (module (func $type-local-arg-void-vs-num (local i32) (set_local 0 (nop)))) + "type mismatch" +) (assert_invalid (module (func $type-local-arg-num-vs-num (local i32) (set_local 0 (f32.const 0)))) "type mismatch" @@ -169,6 +173,10 @@ "type mismatch" ) +(assert_invalid + (module (func $type-param-arg-void-vs-num (param i32) (set_local 0 (nop)))) + "type mismatch" +) (assert_invalid (module (func $type-param-arg-num-vs-num (param i32) (set_local 0 (f32.const 0)))) "type mismatch" From 9d168d53bd2bd93dbfe86111081d246678c92ce0 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Thu, 9 Jun 2016 17:17:58 +0200 Subject: [PATCH 9/9] Remove obsolete exception handlers --- ml-proto/spec/check.ml | 2 +- ml-proto/spec/eval.ml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ml-proto/spec/check.ml b/ml-proto/spec/check.ml index a3a9426a09..a64b88f7df 100644 --- a/ml-proto/spec/check.ml +++ b/ml-proto/spec/check.ml @@ -26,7 +26,7 @@ type context = } let lookup category list x = - try List.nth list x.it with Failure _ | Invalid_argument _ -> + try List.nth list x.it with Failure _ -> error x.at ("unknown " ^ category ^ " " ^ string_of_int x.it) let type_ types x = lookup "function type" types x diff --git a/ml-proto/spec/eval.ml b/ml-proto/spec/eval.ml index 51f465e0f9..d892d74f52 100644 --- a/ml-proto/spec/eval.ml +++ b/ml-proto/spec/eval.ml @@ -65,7 +65,7 @@ type config = } let lookup category list x = - try List.nth list x.it with Failure _ | Invalid_argument _ -> + try List.nth list x.it with Failure _ -> Crash.error x.at ("undefined " ^ category ^ " " ^ string_of_int x.it) let type_ c x = lookup "type" c.instance.module_.it.types x