Fix ref types validation; add null (bytecodealliance#131)

Author: yurydelendik

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wasmparser"
-version = "0.37.2"
+version = "0.38.0"
 authors = ["Yury Delendik <ydelendik@mozilla.com>"]
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/yurydelendik/wasmparser.rs"
@@ -15,7 +15,7 @@ edition = "2018"
 
 [dev-dependencies]
 criterion = "0.2"
-wabt = "0.9.1"
+wabt = "0.9.2"
 
 [dependencies.hashbrown]
 version = "0.5.0"

src/operators_validator.rs

@@ -24,9 +24,12 @@ use crate::primitives::{
 };
 
 /// Test if `subtype` is a subtype of `supertype`.
-fn is_subtype_supertype(subtype: Type, supertype: Type) -> bool {
+pub(crate) fn is_subtype_supertype(subtype: Type, supertype: Type) -> bool {
     match supertype {
-        Type::AnyRef => subtype == Type::AnyRef || subtype == Type::AnyFunc,
+        Type::AnyRef => {
+            subtype == Type::AnyRef || subtype == Type::AnyFunc || subtype == Type::Null
+        }
+        Type::AnyFunc => subtype == Type::AnyFunc || subtype == Type::Null,
         _ => subtype == supertype,
     }
 }
@@ -1319,12 +1322,12 @@ impl OperatorValidator {
             }
             Operator::RefNull => {
                 self.check_reference_types_enabled()?;
-                self.func_state.change_frame_with_type(0, Type::AnyRef)?;
+                self.func_state.change_frame_with_type(0, Type::Null)?;
             }
             Operator::RefIsNull => {
                 self.check_reference_types_enabled()?;
                 self.check_operands(&[Type::AnyRef])?;
-                self.func_state.change_frame_with_type(0, Type::I32)?;
+                self.func_state.change_frame_with_type(1, Type::I32)?;
             }
             Operator::V128Load { ref memarg } => {
                 self.check_simd_enabled()?;

src/primitives.rs

@@ -84,6 +84,7 @@ pub enum Type {
     AnyRef,
     Func,
     EmptyBlockType,
+    Null,
 }
 
 /// Either a value type or a function type.

src/tests.rs

@@ -372,6 +372,9 @@ mod wast_tests {
         if config.operator_config.enable_simd {
             features.enable_simd();
         }
+        if config.operator_config.enable_reference_types {
+            features.enable_reference_types();
+        }
         features
     }
 
@@ -473,6 +476,32 @@ mod wast_tests {
                 _ => false,
             },
         );
+
+        run_proposal_tests(
+            "reference-types",
+            {
+                let mut config: ValidatingParserConfig = default_config();
+                config.operator_config.enable_reference_types = true;
+                config
+            },
+            |name, line| match (name, line) {
+                ("ref_null.wast", _)
+                | ("ref_is_null.wast", _)
+                | ("ref_func.wast", _)
+                | ("linking.wast", _)
+                | ("globals.wast", _)
+                | ("imports.wast", _)
+                | ("br_table.wast", _)
+                | ("select.wast", _)
+                | ("table_get.wast", _)
+                | ("table_set.wast", _)
+                | ("table_size.wast", _)
+                | ("table_fill.wast", _)
+                | ("table_grow.wast", _)
+                | ("exports.wast", _) => true,
+                _ => false,
+            },
+        );
     }
 
     #[test]

src/validator.rs

@@ -34,8 +34,8 @@ use crate::primitives::{
 use crate::parser::{Parser, ParserInput, ParserState, WasmDecoder};
 
 use crate::operators_validator::{
-    FunctionEnd, OperatorValidator, OperatorValidatorConfig, WasmModuleResources,
-    DEFAULT_OPERATOR_VALIDATOR_CONFIG,
+    is_subtype_supertype, FunctionEnd, OperatorValidator, OperatorValidatorConfig,
+    WasmModuleResources, DEFAULT_OPERATOR_VALIDATOR_CONFIG,
 };
 
 use crate::readers::FunctionBody;
@@ -196,6 +196,12 @@ impl<'a> ValidatingParser<'a> {
     fn check_value_type(&self, ty: Type) -> ValidatorResult<'a, ()> {
         match ty {
             Type::I32 | Type::I64 | Type::F32 | Type::F64 => Ok(()),
+            Type::Null | Type::AnyFunc | Type::AnyRef => {
+                if !self.config.operator_config.enable_reference_types {
+                    return self.create_error("reference types support is not enabled");
+                }
+                Ok(())
+            }
             Type::V128 => {
                 if !self.config.operator_config.enable_simd {
                     return self.create_error("SIMD support is not enabled");
@@ -301,6 +307,12 @@ impl<'a> ValidatingParser<'a> {
             Operator::I64Const { .. } => Type::I64,
             Operator::F32Const { .. } => Type::F32,
             Operator::F64Const { .. } => Type::F64,
+            Operator::RefNull => {
+                if !self.config.operator_config.enable_reference_types {
+                    return self.create_error("reference types support is not enabled");
+                }
+                Type::Null
+            }
             Operator::V128Const { .. } => {
                 if !self.config.operator_config.enable_simd {
                     return self.create_error("SIMD support is not enabled");
@@ -315,7 +327,7 @@ impl<'a> ValidatingParser<'a> {
             }
             _ => return self.create_error("invalid init_expr operator"),
         };
-        if ty != state.ty {
+        if !is_subtype_supertype(ty, state.ty) {
             return self.create_error("invalid init_expr type");
         }
         Ok(())