Implement Wasm GrowMemory opcode as a wasm runtime call

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 863 matching lines @@
       op = m->RoundUint64ToFloat64();
       break;
     case wasm::kExprI64SConvertF32:
       return BuildI64SConvertF32(input, position);
     case wasm::kExprI64SConvertF64:
       return BuildI64SConvertF64(input, position);
     case wasm::kExprI64UConvertF32:
       return BuildI64UConvertF32(input, position);
     case wasm::kExprI64UConvertF64:
       return BuildI64UConvertF64(input, position);
+    case wasm::kExprGrowMemory:
+      return BuildGrowMemory(input);
     case wasm::kExprI32AsmjsLoadMem8S:
       return BuildAsmjsLoadMem(MachineType::Int8(), input);
     case wasm::kExprI32AsmjsLoadMem8U:
       return BuildAsmjsLoadMem(MachineType::Uint8(), input);
     case wasm::kExprI32AsmjsLoadMem16S:
       return BuildAsmjsLoadMem(MachineType::Int16(), input);
     case wasm::kExprI32AsmjsLoadMem16U:
       return BuildAsmjsLoadMem(MachineType::Uint16(), input);
     case wasm::kExprI32AsmjsLoadMem:
       return BuildAsmjsLoadMem(MachineType::Int32(), input);
@@ skipping 670 matching lines @@
   trap_->ZeroCheck32(wasm::kTrapFloatUnrepresentable,
                      BuildCCall(sig_builder.Build(), args), position);
   const Operator* load_op = jsgraph()->machine()->Load(result_type);
   Node* load =
       graph()->NewNode(load_op, stack_slot_result, jsgraph()->Int32Constant(0),
                        *effect_, *control_);
   *effect_ = load;
   return load;
 }
 
+Node* WasmGraphBuilder::BuildGrowMemory(Node* input) {
+  Runtime::FunctionId f = Runtime::kWasmGrowMemory;

[ahaas, 2016/06/24 11:10:15]

personal preference: would it be possible to use better variable names than f
and fun? At least function_id instead of f would be nice.

[gdeepti, 2016/06/25 00:28:41]

Done.

+  const Runtime::Function* fun = Runtime::FunctionForId(f);
+  CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
+      jsgraph()->zone(), f, fun->nargs, Operator::kNoProperties,
+      CallDescriptor::kNoFlags);
+  Node** control_ptr = control_;
+  Node** effect_ptr = effect_;
+  wasm::ModuleEnv* module = module_;
+  *control_ptr = graph()->NewNode(jsgraph()->common()->Merge(1), *control_ptr);
+  *effect_ptr = graph()->NewNode(jsgraph()->common()->EffectPhi(1), *effect_ptr,
+                                 *control_ptr);
+  input = BuildChangeUint32ToSmi(input);
+  Node* inputs[] = {
+      jsgraph()->CEntryStubConstant(fun->result_size), input,  // C entry
+      jsgraph()->ExternalConstant(
+          ExternalReference(f, jsgraph()->isolate())),     // ref
+      jsgraph()->Int32Constant(fun->nargs),                // arity
+      jsgraph()->HeapConstant(module->instance->context),  // context
+      *effect_ptr,
+      *control_ptr};
+  Node* node = graph()->NewNode(jsgraph()->common()->Call(desc),
+                                static_cast<int>(arraysize(inputs)), inputs);
+  *control_ptr = node;
+  *effect_ptr = node;
+  node = BuildChangeSmiToInt32(node);
+  return node;
+}
+
 Node* WasmGraphBuilder::BuildI32DivS(Node* left, Node* right,
                                      wasm::WasmCodePosition position) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   trap_->ZeroCheck32(wasm::kTrapDivByZero, right, position);
   Node* before = *control_;
   Node* denom_is_m1;
   Node* denom_is_not_m1;
   Branch(
       graph()->NewNode(m->Word32Equal(), right, jsgraph()->Int32Constant(-1)),
       &denom_is_m1, &denom_is_not_m1);
@@ skipping 691 matching lines @@
 Node* WasmGraphBuilder::BuildChangeSmiToInt32(Node* value) {
   value = graph()->NewNode(jsgraph()->machine()->WordSar(), value,
                            BuildSmiShiftBitsConstant());
   if (jsgraph()->machine()->Is64()) {
     value =
         graph()->NewNode(jsgraph()->machine()->TruncateInt64ToInt32(), value);
   }
   return value;
 }
 
+Node* WasmGraphBuilder::BuildChangeUint32ToSmi(Node* value) {
+  if (jsgraph()->machine()->Is64()) {
+    value =
+        graph()->NewNode(jsgraph()->machine()->ChangeUint32ToUint64(), value);
+  }
+  return graph()->NewNode(jsgraph()->machine()->WordShl(), value,
+                          BuildSmiShiftBitsConstant());
+}
+
 Node* WasmGraphBuilder::BuildChangeSmiToFloat64(Node* value) {
   return graph()->NewNode(jsgraph()->machine()->ChangeInt32ToFloat64(),
                           BuildChangeSmiToInt32(value));
 }
 
 Node* WasmGraphBuilder::BuildTestNotSmi(Node* value) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagMask == 1);
   return graph()->NewNode(jsgraph()->machine()->WordAnd(), value,
                           jsgraph()->IntPtrConstant(kSmiTagMask));
@@ skipping 285 matching lines @@
     if (value < effective_size) {
       // The bounds check will always succeed.
       return;
     }
   }
 
   Node* cond = graph()->NewNode(jsgraph()->machine()->Uint32LessThan(), index,
                                 jsgraph()->RelocatableInt32Constant(
                                     static_cast<uint32_t>(effective_size),
                                     RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
-
   trap_->AddTrapIfFalse(wasm::kTrapMemOutOfBounds, cond, position);
 }
 
 MachineType WasmGraphBuilder::GetTypeForUnalignedAccess(uint32_t alignment,
                                                         bool signExtend) {
   switch (alignment) {
     case 0:
       return signExtend ? MachineType::Int8() : MachineType::Uint8();
     case 1:
       return signExtend ? MachineType::Int16() : MachineType::Uint16();
@@ skipping 669 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8