[wasm] Adding feature to JIT a wasm function at runtime and hook up the compiled code into the indi…

src/compiler/wasm-compiler.cc

 // Copyright 2015 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/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 343 matching lines @@
   Node** buf = Realloc(effects, count, count + 1);
   buf[count] = control;
   return graph()->NewNode(jsgraph()->common()->EffectPhi(count), count + 1,
                           buf);
 }
 
 Node* WasmGraphBuilder::NumberConstant(int32_t value) {
   return jsgraph()->Constant(value);
 }
 
+Node* WasmGraphBuilder::Uint32Constant(uint32_t value) {
+  return jsgraph()->Uint32Constant(value);
+}
+
 Node* WasmGraphBuilder::Int32Constant(int32_t value) {
   return jsgraph()->Int32Constant(value);
 }
 
 Node* WasmGraphBuilder::Int64Constant(int64_t value) {
   return jsgraph()->Int64Constant(value);
 }
 
 Node* WasmGraphBuilder::Binop(wasm::WasmOpcode opcode, Node* left, Node* right,
                               wasm::WasmCodePosition position) {
@@ skipping 1713 matching lines @@
                        graph()->NewNode(machine->Word32Shl(), key,
                                         Int32Constant(kPointerSizeLog2)),
                        Int32Constant(offset)),
       *effect_, *control_);
 
   args[0] = load_code;
   wasm::FunctionSig* sig = module_->GetSignature(index);
   return BuildWasmCall(sig, args, position);
 }
 
+Node* WasmGraphBuilder::JITSingleFunction(Node* base, Node* length, Node* index,
+                                          uint32_t sig_index,

[Mircea Trofin, 2016/07/12 02:49:12]

looks like base, length, index, and sig are all not mutated in this API. Could
you mark them as const?

[John, 2016/07/13 19:56:59]

Const-correctness is good, but it seems this module does not use const for
parameters. Maybe, for consistency, we should let it as is? (of course, then the
lack of const qualifiers become a self-fulfilling prophecy, and nobody will ever
bother to fix...)

[ritesht, 2016/07/13 23:58:44]

Done.

[ritesht, 2016/07/13 23:58:44]

Acknowledged.

+                                          wasm::FunctionSig* sig) {
+  Runtime::FunctionId f = Runtime::kJITSingleFunction;
+  const Runtime::Function* fun = Runtime::FunctionForId(f);
+  // CEntryStubConstant nodes have to be created and cached in the main
+  // thread. At the moment this is only done for CEntryStubConstant(1).
+  DCHECK_EQ(1, fun->result_size);
+  uint32_t return_count = static_cast<uint32_t>(sig->return_count());
+  uint32_t parameter_count = static_cast<uint32_t>(sig->parameter_count());
+
+  uint32_t inputs_size = 13 + return_count + parameter_count;

[Mircea Trofin, 2016/07/12 02:49:12]

what's 13? (is there a constant or should you define perhaps a constant)?

[ritesht, 2016/07/13 23:58:44]

Done.

+  Node** inputs = Buffer(inputs_size);
+  inputs[0] = jsgraph()->CEntryStubConstant(fun->result_size);  // C entry

[Mircea Trofin, 2016/07/12 02:49:12]

remove comment ("// C entry"), doesn't add info.

[ritesht, 2016/07/13 23:58:45]

Done.

+  inputs[1] = BuildChangeUint32ToSmi(base);
+  inputs[2] = BuildChangeUint32ToSmi(length);
+  inputs[3] = BuildChangeUint32ToSmi(index);
+  inputs[4] = BuildChangeIntPtrToSmi(MemBuffer(0));
+  inputs[5] = FunctionTable();
+  inputs[6] = Uint32Constant(sig_index);
+  inputs[7] = BuildChangeUint32ToSmi(Uint32Constant(return_count));
+
+  // Pass in parameters and return types in to the runtime function
+  // to allow it to regenerate signature
+  for (uint32_t i = 0; i < return_count; i++) {

[Mircea Trofin, 2016/07/12 02:49:12]

++i

[ritesht, 2016/07/13 23:58:44]

Done.

+    inputs[i + 8] = BuildChangeUint32ToSmi(
+        Uint32Constant(static_cast<int>(sig->GetReturn(i))));
+  }
+
+  for (uint32_t i = 0; i < parameter_count; i++) {

[Mircea Trofin, 2016/07/12 02:49:12]

++i

[ritesht, 2016/07/13 23:58:44]

Done.

+    inputs[i + 8 + return_count] = BuildChangeUint32ToSmi(
+        Uint32Constant(static_cast<int>(sig->GetParam(i))));
+  }
+
+  const uint32_t args_offset = 8 + return_count + parameter_count;

[Mircea Trofin, 2016/07/12 02:49:12]

could you define constants for all these indices (e.g. the "1" in inputs[1], "8"
in args_offset = 8 + ...), for 
maintainability

[ritesht, 2016/07/13 23:58:44]

Done.

+  inputs[args_offset] = jsgraph()->ExternalConstant(
+      ExternalReference(f, jsgraph()->isolate()));                      // ref
+  inputs[args_offset + 1] = jsgraph()->Int32Constant(args_offset - 1);  // arity
+  inputs[args_offset + 2] =
+      HeapConstant(module_->instance->context);  // context
+  inputs[args_offset + 3] = *effect_;
+  inputs[args_offset + 4] = *control_;
+
+  // Use the module context to call the runtime.
+  CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(

[John, 2016/07/13 19:56:59]

I would probably use auto* here, but auto isn't used anywhere else...

[ritesht, 2016/07/13 23:58:44]

Acknowledged.

+      jsgraph()->zone(), f, args_offset - 1, Operator::kNoProperties,
+      CallDescriptor::kNoFlags);
+
+  Node* node =
+      graph()->NewNode(jsgraph()->common()->Call(desc), inputs_size, inputs);
+  *control_ = node;
+  *effect_ = node;
+  return node;
+}
+
 Node* WasmGraphBuilder::BuildI32Rol(Node* left, Node* right) {
   // Implement Rol by Ror since TurboFan does not have Rol opcode.
   // TODO(weiliang): support Word32Rol opcode in TurboFan.
   Int32Matcher m(right);
   if (m.HasValue()) {
     return Binop(wasm::kExprI32Ror, left,
                  jsgraph()->Int32Constant(32 - m.Value()));
   } else {
     return Binop(wasm::kExprI32Ror, left,
                  Binop(wasm::kExprI32Sub, jsgraph()->Int32Constant(32), right));
@@ skipping 303 matching lines @@
     case wasm::kAstStmt:
       num = jsgraph()->Int32Constant(0);
       break;
     default:
       UNREACHABLE();
       return nullptr;
   }
   return num;
 }
 
+Node* WasmGraphBuilder::BuildChangeIntPtrToSmi(Node* value) {

[Mircea Trofin, 2016/07/12 02:49:12]

"value" is const?

[ritesht, 2016/07/13 23:58:44]

Removed function. No longer needed.

+  return graph()->NewNode(jsgraph()->machine()->WordShl(), value,
+                          BuildSmiShiftBitsConstant());
+}
+
 Node* WasmGraphBuilder::BuildChangeInt32ToSmi(Node* value) {
   if (jsgraph()->machine()->Is64()) {
     value = graph()->NewNode(jsgraph()->machine()->ChangeInt32ToInt64(), value);
   }
   return graph()->NewNode(jsgraph()->machine()->WordShl(), value,
                           BuildSmiShiftBitsConstant());
 }
 
 Node* WasmGraphBuilder::BuildChangeSmiToInt32(Node* value) {
   value = graph()->NewNode(jsgraph()->machine()->WordSar(), value,
@@ skipping 1034 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8