[wasm] Support validation of asm.js modules with != 3 args.

src/compiler.cc

 // Copyright 2012 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.
 
 #include "src/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 458 matching lines @@
 int CodeAndMetadataSize(CompilationInfo* info) {
   if (info->has_bytecode_array()) {
     return info->bytecode_array()->SizeIncludingMetadata();
   }
   return info->code()->SizeIncludingMetadata();
 }
 
 bool GenerateUnoptimizedCode(CompilationInfo* info) {
   bool success;
   EnsureFeedbackMetadata(info);
-  if (FLAG_validate_asm && info->scope()->asm_module()) {
+  if (FLAG_validate_asm && info->scope()->asm_module() &&
+      !info->shared_info()->HasAsmWasmData()) {

[Michael Starzinger, 2016/08/11 11:44:10]

As mentioned in my previous comment, we could go with a bit in the
{CompilationHints} of the {SharedFunctionInfo} to indicate instantiation
failures. Then the clearing itself can be done in Runtime_InstantiateAsmJs as
before.

[bradn, 2016/08/12 01:17:09]

Done.

     MaybeHandle<FixedArray> wasm_data;
     wasm_data = AsmJs::ConvertAsmToWasm(info->parse_info());
     if (!wasm_data.is_null()) {
       info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
       info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
       return true;
     }
   }
+  if (info->shared_info()->HasAsmWasmData()) {
+    info->shared_info()->ClearAsmWasmData();
+  }
   if (ShouldUseIgnition(info)) {
     success = interpreter::Interpreter::MakeBytecode(info);
   } else {
     success = FullCodeGenerator::MakeCode(info);
   }
   if (success) {
     Isolate* isolate = info->isolate();
     Counters* counters = isolate->counters();
     // TODO(4280): Rename counters from "baseline" to "unoptimized" eventually.
     counters->total_baseline_code_size()->Increment(CodeAndMetadataSize(info));
@@ skipping 504 matching lines @@
 
   // Record the function compilation event.
   RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, &info);
 
   return info.code();
 }
 
 MaybeHandle<Code> GetLazyCode(Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
   DCHECK(!isolate->has_pending_exception());
-  DCHECK(!function->is_compiled());
+  DCHECK(!function->is_compiled() ||
+         function->code() ==
+             function->GetIsolate()->builtins()->builtin(

[Michael Starzinger, 2016/08/11 11:44:10]

This can be avoided by adding the following to the failure case in the
Runtime_InstantiateAsmJs function:

DCHECK(function->code() ==
isolate->builtins()->builtin(Builtins::kInstantiateAsmJs));
function->ReplaceCode(isolate->builtins()->builtin(Builtins::kCompileLazy));

[bradn, 2016/08/12 01:17:09]

Done.

+                 Builtins::kInstantiateAsmJs));
   TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
   RuntimeCallTimerScope runtimeTimer(isolate,
                                      &RuntimeCallStats::CompileCodeLazy);
   TRACE_EVENT_RUNTIME_CALL_STATS_TRACING_SCOPED(
       isolate, &tracing::TraceEventStatsTable::CompileCodeLazy);
   AggregatedHistogramTimerScope timer(isolate->counters()->compile_lazy());
 
   if (FLAG_turbo_cache_shared_code) {
     Handle<Code> cached_code;
     if (GetCodeFromOptimizedCodeMap(function, BailoutId::None())
             .ToHandle(&cached_code)) {
       if (FLAG_trace_opt) {
         PrintF("[found optimized code for ");
         function->ShortPrint();
         PrintF(" during unoptimized compile]\n");
       }
       DCHECK(function->shared()->is_compiled());
       return cached_code;
     }
   }
 
-  if (function->shared()->is_compiled()) {
+  if (function->shared()->is_compiled() &&

[Michael Starzinger, 2016/08/11 11:44:10]

This can be avoided by adding the following to the failure case in the
Runtime_InstantiateAsmJs function:

if (shared->code() == isolate->builtins()->builtin(Builtins::kInstantiateAsmJs))
{
  shared->ReplaceCode(isolate->builtins()->builtin(Builtins::kCompileLazy));
}

[bradn, 2016/08/12 01:17:09]

Done.

+      function->code() !=
+          function->GetIsolate()->builtins()->builtin(
+              Builtins::kInstantiateAsmJs)) {
     return Handle<Code>(function->shared()->code());
   }
 
   Zone zone(isolate->allocator());
   ParseInfo parse_info(&zone, function);
   CompilationInfo info(&parse_info, function);
   Handle<Code> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCode(&info), Code);
 
   if (FLAG_always_opt) {
@@ skipping 159 matching lines @@
 
 bool Compiler::ParseAndAnalyze(ParseInfo* info) {
   if (!Parser::ParseStatic(info)) return false;
   if (!Compiler::Analyze(info)) return false;
   DCHECK_NOT_NULL(info->literal());
   DCHECK_NOT_NULL(info->scope());
   return true;
 }
 
 bool Compiler::Compile(Handle<JSFunction> function, ClearExceptionFlag flag) {
-  if (function->is_compiled()) return true;
+  if (function->is_compiled() &&

[Michael Starzinger, 2016/08/11 11:44:10]

Likewise.

[bradn, 2016/08/12 01:17:09]

Done.

+      function->code() !=
+          function->GetIsolate()->builtins()->builtin(
+              Builtins::kInstantiateAsmJs))
+    return true;
   Isolate* isolate = function->GetIsolate();
   DCHECK(AllowCompilation::IsAllowed(isolate));
 
   // Start a compilation.
   Handle<Code> code;
   if (!GetLazyCode(function).ToHandle(&code)) {
     if (flag == CLEAR_EXCEPTION) {
       isolate->clear_pending_exception();
     }
     return false;
@@ skipping 723 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8