[wasm] Lazy compilation for asm.js

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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 162 matching lines @@
   }
 
   // Add a check that traps if {node} is zero.
   Node* ZeroCheck64(wasm::TrapReason reason, Node* node,
                     wasm::WasmCodePosition position) {
     return TrapIfEq64(reason, node, 0, position);
   }
 
   Builtins::Name GetBuiltinIdForTrap(wasm::TrapReason reason) {
     bool in_cctest =
-        !builder_->module_ || builder_->module_->instance->context.is_null();
+        !builder_->module_ || (builder_->module_->instance &&
+                               builder_->module_->instance->context.is_null());
     if (in_cctest) {
       // We use Builtins::builtin_count as a marker to tell the code generator
       // to generate a call to a testing c-function instead of a runtime
       // function. This code should only be called from a cctest.
       return Builtins::builtin_count;
     }
 
     switch (reason) {
 #define TRAPREASON_TO_MESSAGE(name) \
   case wasm::k##name:               \
@@ skipping 286 matching lines @@
 }
 
 Node* WasmGraphBuilder::Int64Constant(int64_t value) {
   return jsgraph()->Int64Constant(value);
 }
 
 void WasmGraphBuilder::StackCheck(wasm::WasmCodePosition position,
                                   Node** effect, Node** control) {
   if (FLAG_wasm_no_stack_checks) return;
   // We do not generate stack checks for cctests.
-  if (!module_ || module_->instance->context.is_null()) return;
+  if (!module_ || (module_->instance && module_->instance->context.is_null()))
+    return;
   if (effect == nullptr) effect = effect_;
   if (control == nullptr) control = control_;
 
   Node* limit = graph()->NewNode(
       jsgraph()->machine()->Load(MachineType::Pointer()),
       jsgraph()->ExternalConstant(
           ExternalReference::address_of_stack_limit(jsgraph()->isolate())),
       jsgraph()->IntPtrConstant(0), *effect, *control);
   Node* pointer = graph()->NewNode(jsgraph()->machine()->LoadStackPointer());
 
@@ skipping 1288 matching lines @@
                      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::GrowMemory(Node* input) {
+  // GrowMemory will not be called from asm.js, hence we cannot be in
+  // lazy-compilation mode, hence the instance will be set.
+  DCHECK_NOT_NULL(module_);
+  DCHECK_NOT_NULL(module_->instance);
+
   Diamond check_input_range(
       graph(), jsgraph()->common(),
       graph()->NewNode(jsgraph()->machine()->Uint32LessThanOrEqual(), input,
                        jsgraph()->Uint32Constant(FLAG_wasm_max_mem_pages)),
       BranchHint::kTrue);
 
   check_input_range.Chain(*control_);
 
   Node* parameters[] = {BuildChangeUint32ToSmi(input)};
   Node* old_effect = *effect_;
@@ skipping 470 matching lines @@
     }
   }
   return call;
 }
 
 Node* WasmGraphBuilder::CallDirect(uint32_t index, Node** args, Node*** rets,
                                    wasm::WasmCodePosition position) {
   DCHECK_NULL(args[0]);
 
   // Add code object as constant.
-  Handle<Code> code = module_->GetFunctionCode(index);
+  Handle<Code> code = module_->instance
+                          ? module_->GetFunctionCode(index)
+                          : jsgraph()->isolate()->builtins()->Illegal();
   DCHECK(!code.is_null());
   args[0] = HeapConstant(code);
   wasm::FunctionSig* sig = module_->GetFunctionSignature(index);
 
   return BuildWasmCall(sig, args, rets, position);
 }
 
 Node* WasmGraphBuilder::CallIndirect(uint32_t sig_index, Node** args,
                                      Node*** rets,
                                      wasm::WasmCodePosition position) {
   DCHECK_NOT_NULL(args[0]);
-  DCHECK(module_ && module_->instance);
+  DCHECK_NOT_NULL(module_);
 
   // Assume only one table for now.
   uint32_t table_index = 0;
   wasm::FunctionSig* sig = module_->GetSignature(sig_index);
 
   DCHECK(module_->IsValidTable(table_index));
 
   EnsureFunctionTableNodes();
   MachineOperatorBuilder* machine = jsgraph()->machine();
   Node* key = args[0];
@@ skipping 724 matching lines @@
       MachineType load_rep =
           wasm::WasmOpcodes::MachineTypeFor(sig->GetReturn());
       val = graph()->NewNode(jsgraph()->machine()->Load(load_rep), arg_buffer,
                              Int32Constant(0), *effect_, *control_);
     }
     Return(val);
   }
 }
 
 Node* WasmGraphBuilder::MemBuffer(uint32_t offset) {
-  DCHECK(module_ && module_->instance);
+  DCHECK_NOT_NULL(module_);
+  uintptr_t mem_start = reinterpret_cast<uintptr_t>(
+      module_->instance ? module_->instance->mem_start : nullptr);
   if (offset == 0) {
     if (!mem_buffer_) {
       mem_buffer_ = jsgraph()->RelocatableIntPtrConstant(
-          reinterpret_cast<uintptr_t>(module_->instance->mem_start),
-          RelocInfo::WASM_MEMORY_REFERENCE);
+          mem_start, RelocInfo::WASM_MEMORY_REFERENCE);
     }
     return mem_buffer_;
   } else {
     return jsgraph()->RelocatableIntPtrConstant(
-        reinterpret_cast<uintptr_t>(module_->instance->mem_start + offset),
-        RelocInfo::WASM_MEMORY_REFERENCE);
+        mem_start + offset, RelocInfo::WASM_MEMORY_REFERENCE);
   }
 }
 
 Node* WasmGraphBuilder::CurrentMemoryPages() {
+  // CurrentMemoryPages will not be called from asm.js, hence we cannot be in
+  // lazy-compilation mode, hence the instance will be set.
+  DCHECK_EQ(wasm::kWasmOrigin, module_->module->origin);
+  DCHECK_NOT_NULL(module_);
+  DCHECK_NOT_NULL(module_->instance);
+
   Runtime::FunctionId function_id = Runtime::kWasmMemorySize;
   const Runtime::Function* function = Runtime::FunctionForId(function_id);
   CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
       jsgraph()->zone(), function_id, function->nargs, Operator::kNoThrow,
       CallDescriptor::kNoFlags);
   Node* inputs[] = {
       jsgraph()->CEntryStubConstant(function->result_size),  // C entry
       jsgraph()->ExternalConstant(
           ExternalReference(function_id, jsgraph()->isolate())),  // ref
       jsgraph()->Int32Constant(function->nargs),                  // arity
@@ skipping 13 matching lines @@
   DCHECK_NOT_NULL(module_);
   if (mem_size_) return mem_size_;
   uint32_t size = module_->instance ? module_->instance->mem_size : 0;
   mem_size_ = jsgraph()->RelocatableInt32Constant(
       size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   return mem_size_;
 }
 
 void WasmGraphBuilder::EnsureFunctionTableNodes() {
   if (function_tables_.size() > 0) return;
-  size_t tables_size = module_->instance->function_tables.size();
-  DCHECK(tables_size == module_->instance->signature_tables.size());
+  size_t tables_size = module_->module->function_tables.size();
+  if (module_->instance) {
+    DCHECK_EQ(tables_size, module_->instance->function_tables.size());
+    DCHECK_EQ(tables_size, module_->instance->signature_tables.size());
+  }
   for (size_t i = 0; i < tables_size; ++i) {
-    auto function_handle = module_->instance->function_tables[i];
-    auto signature_handle = module_->instance->signature_tables[i];
+    auto function_handle = module_->GetFunctionTableObj(i);
+    auto signature_handle = module_->GetSignatureTableObj(i);
     DCHECK(!function_handle.is_null() && !signature_handle.is_null());
     function_tables_.push_back(HeapConstant(function_handle));
     signature_tables_.push_back(HeapConstant(signature_handle));
     uint32_t table_size = module_->module->function_tables[i].min_size;
     function_table_sizes_.push_back(jsgraph()->RelocatableInt32Constant(
         static_cast<uint32_t>(table_size),
         RelocInfo::WASM_FUNCTION_TABLE_SIZE_REFERENCE));
   }
 }
 
 Node* WasmGraphBuilder::GetGlobal(uint32_t index) {
   MachineType mem_type =
       wasm::WasmOpcodes::MachineTypeFor(module_->GetGlobalType(index));
+  byte* globals_start =
+      module_->instance ? module_->instance->globals_start : nullptr;
+  uintptr_t global_addr = reinterpret_cast<uintptr_t>(
+      globals_start + module_->module->globals[index].offset);
   Node* addr = jsgraph()->RelocatableIntPtrConstant(
-      reinterpret_cast<uintptr_t>(module_->instance->globals_start +
-                                  module_->module->globals[index].offset),
-      RelocInfo::WASM_GLOBAL_REFERENCE);
+      global_addr, RelocInfo::WASM_GLOBAL_REFERENCE);
   const Operator* op = jsgraph()->machine()->Load(mem_type);
   Node* node = graph()->NewNode(op, addr, jsgraph()->Int32Constant(0), *effect_,
                                 *control_);
   *effect_ = node;
   return node;
 }
 
 Node* WasmGraphBuilder::SetGlobal(uint32_t index, Node* val) {
   MachineType mem_type =
       wasm::WasmOpcodes::MachineTypeFor(module_->GetGlobalType(index));
+  byte* globals_start =
+      module_->instance ? module_->instance->globals_start : 0;
   Node* addr = jsgraph()->RelocatableIntPtrConstant(
-      reinterpret_cast<uintptr_t>(module_->instance->globals_start +
+      reinterpret_cast<uintptr_t>(globals_start +
                                   module_->module->globals[index].offset),
       RelocInfo::WASM_GLOBAL_REFERENCE);
   const Operator* op = jsgraph()->machine()->Store(
       StoreRepresentation(mem_type.representation(), kNoWriteBarrier));
   Node* node = graph()->NewNode(op, addr, jsgraph()->Int32Constant(0), val,
                                 *effect_, *control_);
   *effect_ = node;
   return node;
 }
 
@@ skipping 1096 matching lines @@
     wasm::ErrorThrower* thrower, Isolate* isolate,
     wasm::ModuleBytesEnv* module_env, const wasm::WasmFunction* function) {
   WasmCompilationUnit unit(isolate, module_env, function);
   unit.ExecuteCompilation();
   return unit.FinishCompilation(thrower);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8