[wasm-hint] Add Test Cases for Streaming Compilation

Tests streaming compilation with Wasm compilation hints enabled. In
particular, validation errors in lazily compiled functions are covered.

Bug: v8:9003
Change-Id: I81611988b8451ce2f6562962dbd50561f5086aef
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1561310
Commit-Queue: Frederik Gossen <frgossen@google.com>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#60839}

src/wasm/module-compiler.cc

@@ -339,6 +339,7 @@ class CompilationStateImpl {
   }
 
   CompileMode compile_mode() const { return compile_mode_; }
+  Counters* counters() const { return async_counters_.get(); }
   WasmFeatures* detected_features() { return &detected_features_; }
 
   void SetWireBytesStorage(
@@ -1695,24 +1696,37 @@ bool AsyncStreamingProcessor::ProcessFunctionBody(Vector<const uint8_t> bytes,
   decoder_.DecodeFunctionBody(
       num_functions_, static_cast<uint32_t>(bytes.length()), offset, false);
 
+  NativeModule* native_module = job_->native_module_.get();
+  const WasmModule* module = native_module->module();
   uint32_t func_index =
       num_functions_ + decoder_.module()->num_imported_functions;
 
-  NativeModule* native_module = job_->native_module_.get();
-  if (IsLazyCompilation(native_module->module(), native_module,
+  if (IsLazyCompilation(module, native_module,
                         native_module->enabled_features(), func_index)) {
-    ErrorThrower thrower(job_->isolate(), "WebAssembly.compile()");
-    auto counters = job_->isolate()->counters();
-    auto allocator = job_->isolate()->allocator();
-    ValidateSequentially(counters, allocator, native_module, func_index,
-                         &thrower);
-    native_module->UseLazyStub(func_index);
-    if (thrower.error()) {
-      // TODO(frgossen): Add test coverage for this path.
-      DCHECK(native_module->enabled_features().compilation_hints);
-      thrower.Reset();
+    // TODO(frgossen): Unify this code with {ValidateSequentially}. Note, that
+    // the native moudle does not own the wire bytes until {SetWireBytes} is
+    // called in {OnFinishedStream}. Validation must threfore use the {bytes}
+    // parameter.
+    const WasmFunction* func = &module->functions[func_index];
+    FunctionBody body{func->sig, func->code.offset(), bytes.start(),
+                      bytes.end()};
+    DecodeResult result;
+    {
+      Counters* counters = Impl(native_module->compilation_state())->counters();
+      auto time_counter = SELECT_WASM_COUNTER(counters, module->origin,
+                                              wasm_decode, function_time);
+
+      TimedHistogramScope wasm_decode_function_time_scope(time_counter);
+      WasmFeatures detected;
+      result = VerifyWasmCode(native_module->engine()->allocator(),
+                              native_module->enabled_features(), module,
+                              &detected, body);
+    }
+    if (result.failed()) {
+      FinishAsyncCompileJobWithError(result.error());
       return false;
     }
+    native_module->UseLazyStub(func_index);
   } else {
     compilation_unit_builder_->AddUnits(func_index);
   }

test/mjsunit/wasm/compilation-hints-compiler.js

+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+// Flags: --experimental-wasm-compilation-hints --wasm-test-streaming
+
+load('test/mjsunit/wasm/wasm-module-builder.js');
+
+(function testInstantiateStreamingWithLazyHint() {
+  print(arguments.callee.name);
+  let builder = new WasmModuleBuilder();
+  builder.addImport('mod', 'pow', kSig_i_ii);
+  builder.addFunction('upow', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+  builder.addFunction('upow2', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+         .giveCompilationHint(kCompilationHintStrategyLazy,
+                              kCompilationHintTierDefault,
+                              kCompilationHintTierDefault)
+         .exportFunc();
+  let bytes = builder.toBuffer();
+  assertPromiseResult(WebAssembly.instantiateStreaming(Promise.resolve(bytes), {mod: {pow: Math.pow}}).then(
+    ({module, instance}) => assertEquals(27, instance.exports.upow2(3))));
+})();
+
+(function testInstantiateStreamingWithBadHint() {
+  print(arguments.callee.name);
+  let builder = new WasmModuleBuilder();
+  builder.addImport('mod', 'pow', kSig_i_ii);
+  builder.addFunction('upow', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+  builder.addFunction('upow2', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+         .giveCompilationHint(kCompilationHintStrategyLazy,
+                              kCompilationHintTierOptimized,
+                              kCompilationHintTierBaseline)
+         .exportFunc();
+  let bytes = builder.toBuffer();
+  assertPromiseResult(WebAssembly.instantiateStreaming(Promise.resolve(bytes), {mod: {pow: Math.pow}}).then(
+    assertUnreachable,
+    error => assertEquals("WebAssembly.compile(): Invalid compilation hint 0x2d (forbidden downgrade) @+78", error.message)));
+})();
+
+(function testInstantiateStreamingWithBadFunctionBody() {
+  print(arguments.callee.name);
+  let invalidFunctionCode = 0x65;
+  let builder = new WasmModuleBuilder();
+  builder.addImport('mod', 'pow', kSig_f_ff);
+  builder.addFunction('upow', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+  builder.addFunction('upow2', kSig_i_i)
+         .addBody([kExprGetLocal, 0,
+                   kExprGetLocal, 0,
+                   kExprCallFunction, 0])
+         .giveCompilationHint(kCompilationHintStrategyLazy,
+                              kCompilationHintTierDefault,
+                              kCompilationHintTierDefault)
+         .exportFunc();
+  let bytes = builder.toBuffer();
+  assertPromiseResult(WebAssembly.instantiateStreaming(Promise.resolve(bytes), {mod: {pow: Math.pow}}).then(
+    assertUnreachable,
+    error => assertEquals("WebAssembly.compile(): call[1] expected type f32, found get_local of type i32 @+94", error.message)));
+})();