Fix dead code validation for multivalue block (bytecodealliance#193)

* Fix dead code validation for multivalue block

Avoid assert/numeric overflow assotiated with "borrowing" unknown stack types from polymorphyc stack when multivalue block is created.

* Update src/operators_validator.rs

Co-Authored-By: Nick Fitzgerald <fitzgen@gmail.com>

* Add wast tests, get wasm features flags from wast

Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com>

Author: yurydelendik

src/operators_validator.rs

@@ -36,10 +36,15 @@ pub(crate) fn is_subtype_supertype(subtype: Type, supertype: Type) -> bool {
 struct BlockState {
     start_types: Vec<Type>,
     return_types: Vec<Type>,
+    // Position in `FuncState::stack_types` array where block values
+    // start.
     stack_starts_at: usize,
     jump_to_top: bool,
     is_else_allowed: bool,
     is_dead_code: bool,
+    // Amount of the required polymorphic values at the stack_starts_at
+    // position in `FuncState::stack_types` array. These values are
+    // fictitious and are not actually present in the stack_types.
     polymorphic_values: Option<usize>,
 }
 
@@ -154,6 +159,7 @@ impl FuncState {
             }
         };
         if block_type == BlockType::If {
+            // Collect conditional value from the stack_types.
             let last_block = self.blocks.last().unwrap();
             if !last_block.is_stack_polymorphic()
                 || self.stack_types.len() > last_block.stack_starts_at
@@ -167,15 +173,28 @@ impl FuncState {
                 return Err(OperatorValidatorError::new("stack operand type mismatch"));
             }
         }
-        let stack_starts_at = self.stack_types.len() - start_types.len();
+        let (stack_starts_at, polymorphic_values) = {
+            // When stack for last block is polymorphic, ensure that
+            // the polymorphic_values matches, and next block is informed about that.
+            let last_block = self.blocks.last_mut().unwrap();
+            if !last_block.is_stack_polymorphic()
+                || last_block.stack_starts_at + start_types.len() <= self.stack_types.len()
+            {
+                (self.stack_types.len() - start_types.len(), None)
+            } else {
+                let unknown_stack_types_len =
+                    last_block.stack_starts_at + start_types.len() - self.stack_types.len();
+                (last_block.stack_starts_at, Some(unknown_stack_types_len))
+            }
+        };
         self.blocks.push(BlockState {
             start_types,
             return_types,
             stack_starts_at,
             jump_to_top: block_type == BlockType::Loop,
             is_else_allowed: block_type == BlockType::If,
             is_dead_code: false,
-            polymorphic_values: None,
+            polymorphic_values,
         });
         Ok(())
     }

src/tests.rs

@@ -342,6 +342,26 @@ mod wast_tests {
         }
     }
 
+    fn extract_config(wast: &str) -> ValidatingParserConfig {
+        let first = wast.split('\n').next();
+        if first.is_none() || !first.unwrap().starts_with(";;; ") {
+            return default_config();
+        }
+        let first = first.unwrap();
+        ValidatingParserConfig {
+            operator_config: OperatorValidatorConfig {
+                enable_threads: first.contains("--enable-threads"),
+                enable_reference_types: first.contains("--enable-reference-types"),
+                enable_simd: first.contains("--enable-simd"),
+                enable_bulk_memory: first.contains("--enable-bulk-memory"),
+                enable_multi_value: first.contains("--enable-multi-value"),
+
+                #[cfg(feature = "deterministic")]
+                deterministic_only: true,
+            },
+        }
+    }
+
     fn validate_module(
         mut module: wast::Module,
         config: ValidatingParserConfig,
@@ -545,10 +565,11 @@ mod wast_tests {
             }
 
             let data = read(&dir.path()).expect("wast data");
+            let config = extract_config(&String::from_utf8_lossy(&data));
             run_wabt_scripts(
                 dir.file_name().to_str().expect("name"),
                 &data,
-                default_config(),
+                config,
                 |_, _| false,
             );
         }

tests/invalid/issue192.wasm

@@ -0,0 +1,30 @@
+;;; --enable-multi-value
+(module
+  (func
+    (unreachable)
+    (block (param i32)
+        (drop)
+    )
+  )
+)
+
+(assert_invalid
+    (module
+        (func
+            (unreachable)
+            (block (param i32))
+        )
+    )
+    "type mismatch: stack size does not match block type"
+)
+
+(assert_invalid
+    (module
+        (func
+            (block (param i32)
+                (drop)
+            )
+        )
+    )
+    "type mismatch: not enough operands"
+)