Hooking up asm-wasm conversion.

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 "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 13 matching lines @@
 #include "src/isolate-inl.h"
 #include "src/log-inl.h"
 #include "src/messages.h"
 #include "src/parsing/parser.h"
 #include "src/parsing/rewriter.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/runtime-profiler.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/typing-asm.h"
 #include "src/vm-state-inl.h"
+#include "src/wasm/wasm-js.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define PARSE_INFO_GETTER(type, name)  \
   type CompilationInfo::name() const { \
     CHECK(parse_info());               \
     return parse_info()->name();       \
   }
@@ skipping 419 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 defined(V8_TARGET_ARCH_X64)
+  // TODO(bradnelson): Implement builtin and enable for other arches.
   if (FLAG_validate_asm && info->scope()->asm_module()) {
-    AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
-                   info->literal());
-    if (FLAG_enable_simd_asmjs) {
-      typer.set_allow_simd(true);
-    }
-    if (!typer.Validate()) {
-      DCHECK(!info->isolate()->has_pending_exception());
-      PrintF("Validation of asm.js module failed: %s", typer.error_message());
+    Handle<FixedArray> wasm_data;
+    if (WasmJs::ConvertAsmToWasm(info->parse_info(), true, &wasm_data)) {
+      info->shared_info()->set_asm_wasm_data(*wasm_data);
+      info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
+      return true;
     }
   }
+#endif
   if (FLAG_ignition && UseIgnition(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 230 matching lines @@
   return true;
 }
 
 MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
                                    Compiler::ConcurrencyMode mode,
                                    BailoutId osr_ast_id = BailoutId::None(),
                                    JavaScriptFrame* osr_frame = nullptr) {
   Isolate* isolate = function->GetIsolate();
   Handle<SharedFunctionInfo> shared(function->shared(), isolate);
 
+  if (shared->HasAsmWasmData()) {

[Michael Starzinger, 2016/06/29 08:29:23]

Can you elaborate on this guard. Is this needed for correctness? AFAICT the
runtime profiler should never be able to record ticks in the module code. So
this guard is confusing me. Is it possible to drop this guard?

[bradn, 2016/06/30 07:59:36]

Not needed. Leftover from prior ignorance on my part.
Dropped.

+    return MaybeHandle<Code>();
+  }
+
   Handle<Code> cached_code;
   if (GetCodeFromOptimizedCodeMap(function, osr_ast_id)
           .ToHandle(&cached_code)) {
     if (FLAG_trace_opt) {
       PrintF("[found optimized code for ");
       function->ShortPrint();
       if (!osr_ast_id.IsNone()) {
         PrintF(" at OSR AST id %d", osr_ast_id.ToInt());
       }
       PrintF("]\n");
@@ skipping 1076 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