Hooking up asm-wasm conversion.

src/builtins.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/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/ieee754.h"
@@ skipping 10 matching lines @@
 #include "src/isolate-inl.h"
 #include "src/json-parser.h"
 #include "src/json-stringifier.h"
 #include "src/messages.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/property-descriptor.h"
 #include "src/prototype.h"
 #include "src/string-builder.h"
 #include "src/uri.h"
 #include "src/vm-state-inl.h"
+#include "src/wasm/wasm-js.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 // Arguments object passed to C++ builtins.
 template <BuiltinExtraArguments extra_args>
 class BuiltinArguments : public Arguments {
  public:
@@ skipping 5303 matching lines @@
   return HandleApiCallAsFunctionOrConstructor(isolate, false, args);
 }
 
 
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a construct call.
 BUILTIN(HandleApiCallAsConstructor) {
   return HandleApiCallAsFunctionOrConstructor(isolate, true, args);
 }
 
+BUILTIN(CompileAsmJs) {

[Michael Starzinger, 2016/06/13 14:10:43]

nit: Could we call this InstantiateAsmJs (or similar) instead? Because IIUC this
is the actual module instntiation code. It is not really triggering compilation.

[bradnelson, 2016/06/27 07:56:10]

Done.

+  HandleScope handleScope(isolate);
+  Handle<JSObject> foreign;
+  if (args.length() > 2) {
+    foreign = args.at<i::JSObject>(2);
+  }
+  Handle<JSArrayBuffer> memory;
+  if (args.length() > 3 && args[3]->IsJSArrayBuffer()) {
+    memory = args.at<i::JSArrayBuffer>(3);
+  }
+  Handle<JSFunction> function = args.target<i::JSFunction>();
+  Handle<Object> result;
+  if (args.length() > 1 &&
+      WasmJs::InstantiateAsmWasm(isolate,
+                                 handle(function->shared()->asm_wasm_data()),
+                                 memory, foreign, &result)) {
+    return *result;
+  } else {
+    function->shared()->ClearAsmWasmData();
+    StackLimitCheck check(isolate);
+    if (check.JsHasOverflowed(1 * KB)) return isolate->StackOverflow();
+    if (!Compiler::CompileBaseline(function)) {
+      return isolate->heap()->exception();
+    }
+    DCHECK(function->is_compiled());
+    return function->code();

[Michael Starzinger, 2016/06/13 14:10:43]

This will return the compiled code to JavaScript. IIUC we should tail-call into
this code so that it can instantiate the asm.js module and return the module
instead. I am not sure this can be expressed in C++ code. I think this needs to
be implemented as an assembly builtin (preferably using the TurboFan
CodeStubAssembler).

[bradnelson, 2016/06/27 07:56:10]

Struggled with this a bit.

I don't believe it can be expressed with the code stub assembler currently. (I
might be game to add it, if you think supporting a non-local goto is feasible?)

It requires being able to speculatively call a function, then return swallowing
a frame on success, or tail call to generated code. Both of which are currently
per arch.

Eager to hear if you've got better ideas :-)

+  }
+}
+
 namespace {
 
 void Generate_LoadIC_Miss(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* name = assembler->Parameter(1);
   Node* slot = assembler->Parameter(2);
   Node* vector = assembler->Parameter(3);
   Node* context = assembler->Parameter(4);
@@ skipping 641 matching lines @@
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_S
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8