Merged changes to avoid OOM for large wasm modules.

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 48 matching lines @@
 void MergeControlToEnd(JSGraph* jsgraph, Node* node) {
   Graph* g = jsgraph->graph();
   if (g->end()) {
     NodeProperties::MergeControlToEnd(g, jsgraph->common(), node);
   } else {
     g->SetEnd(g->NewNode(jsgraph->common()->End(1), node));
   }
 }
 
 Node* BuildModifyThreadInWasmFlag(bool new_value, JSGraph* jsgraph,
-                                  Node** effect_ptr, Node* control) {
+                                  Node* centry_stub_node, Node** effect_ptr,
+                                  Node* control) {
   // TODO(eholk): generate code to modify the thread-local storage directly,
   // rather than calling the runtime.
   if (!trap_handler::UseTrapHandler()) {
     return control;
   }
 
   const Runtime::FunctionId f =
       new_value ? Runtime::kSetThreadInWasm : Runtime::kClearThreadInWasm;
   const Runtime::Function* fun = Runtime::FunctionForId(f);
   DCHECK_EQ(0, fun->nargs);
   const CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
       jsgraph->zone(), f, fun->nargs, Operator::kNoProperties,
       CallDescriptor::kNoFlags);
   // 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);
-  Node* inputs[] = {jsgraph->CEntryStubConstant(fun->result_size),
+  Node* inputs[] = {centry_stub_node,
                     jsgraph->ExternalConstant(
                         ExternalReference(f, jsgraph->isolate())),  // ref
                     jsgraph->Int32Constant(fun->nargs),             // arity
                     jsgraph->NoContextConstant(),
                     *effect_ptr,
                     control};
 
   Node* node = jsgraph->graph()->NewNode(jsgraph->common()->Call(desc),
                                          arraysize(inputs), inputs);
   *effect_ptr = node;
   return node;
 }
 
 // Only call this function for code which is not reused across instantiations,
 // as we do not patch the embedded context.
 Node* BuildCallToRuntimeWithContext(Runtime::FunctionId f, JSGraph* jsgraph,
-                                    Node* context, Node** parameters,
-                                    int parameter_count, Node** effect_ptr,
-                                    Node** control) {
+                                    Node* centry_stub_node, Node* context,
+                                    Node** parameters, int parameter_count,
+                                    Node** effect_ptr, Node** control) {
   // Setting and clearing the thread-in-wasm flag should not be done as a normal
   // runtime call.
   DCHECK_NE(f, Runtime::kSetThreadInWasm);
   DCHECK_NE(f, Runtime::kClearThreadInWasm);
   // We're leaving Wasm code, so clear the flag.
-  *control = BuildModifyThreadInWasmFlag(false, jsgraph, effect_ptr, *control);
+  *control = BuildModifyThreadInWasmFlag(false, jsgraph, centry_stub_node,
+                                         effect_ptr, *control);
 
   const Runtime::Function* fun = Runtime::FunctionForId(f);
   CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
       jsgraph->zone(), f, fun->nargs, Operator::kNoProperties,
       CallDescriptor::kNoFlags);
   // 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);
   // At the moment we only allow 3 parameters. If more parameters are needed,
   // increase this constant accordingly.
   static const int kMaxParams = 3;
   DCHECK_GE(kMaxParams, parameter_count);
   Node* inputs[kMaxParams + 6];
   int count = 0;
-  inputs[count++] = jsgraph->CEntryStubConstant(fun->result_size);
+  inputs[count++] = centry_stub_node;
   for (int i = 0; i < parameter_count; i++) {
     inputs[count++] = parameters[i];
   }
   inputs[count++] = jsgraph->ExternalConstant(
       ExternalReference(f, jsgraph->isolate()));         // ref
   inputs[count++] = jsgraph->Int32Constant(fun->nargs);  // arity
   inputs[count++] = context;                             // context
   inputs[count++] = *effect_ptr;
   inputs[count++] = *control;
 
   Node* node =
       jsgraph->graph()->NewNode(jsgraph->common()->Call(desc), count, inputs);
   *effect_ptr = node;
 
   // Restore the thread-in-wasm flag, since we have returned to Wasm.
-  *control = BuildModifyThreadInWasmFlag(true, jsgraph, effect_ptr, *control);
+  *control = BuildModifyThreadInWasmFlag(true, jsgraph, centry_stub_node,
+                                         effect_ptr, *control);
 
   return node;
 }
 
 Node* BuildCallToRuntime(Runtime::FunctionId f, JSGraph* jsgraph,
-                         Node** parameters, int parameter_count,
-                         Node** effect_ptr, Node** control) {
-  return BuildCallToRuntimeWithContext(f, jsgraph, jsgraph->NoContextConstant(),
-                                       parameters, parameter_count, effect_ptr,
-                                       control);
+                         Node* centry_stub_node, Node** parameters,
+                         int parameter_count, Node** effect_ptr,
+                         Node** control) {
+  return BuildCallToRuntimeWithContext(f, jsgraph, centry_stub_node,
+                                       jsgraph->NoContextConstant(), parameters,
+                                       parameter_count, effect_ptr, control);
 }
 
 }  // namespace
 
 WasmGraphBuilder::WasmGraphBuilder(
     wasm::ModuleEnv* module_env, Zone* zone, JSGraph* jsgraph,
-    wasm::FunctionSig* sig,
+    Handle<Code> centry_stub, wasm::FunctionSig* sig,
     compiler::SourcePositionTable* source_position_table)
     : zone_(zone),
       jsgraph_(jsgraph),
+      centry_stub_node_(jsgraph_->HeapConstant(centry_stub)),
       module_(module_env),
       signature_tables_(zone),
       function_tables_(zone),
       function_table_sizes_(zone),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
       sig_(sig),
       source_position_table_(source_position_table) {
   for (size_t i = sig->parameter_count(); i > 0 && !has_simd_; --i) {
     if (sig->GetParam(i - 1) == wasm::kWasmS128) has_simd_ = true;
@@ skipping 1541 matching lines @@
   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_;
-  Node* call = BuildCallToRuntime(Runtime::kWasmGrowMemory, jsgraph(),
-                                  parameters, arraysize(parameters), effect_,
-                                  &check_input_range.if_true);
+  Node* call = BuildCallToRuntime(
+      Runtime::kWasmGrowMemory, jsgraph(), centry_stub_node_, parameters,
+      arraysize(parameters), effect_, &check_input_range.if_true);
 
   Node* result = BuildChangeSmiToInt32(call);
 
   result = check_input_range.Phi(MachineRepresentation::kWord32, result,
                                  jsgraph()->Int32Constant(-1));
   *effect_ = graph()->NewNode(jsgraph()->common()->EffectPhi(2), *effect_,
                               old_effect, check_input_range.merge);
   *control_ = check_input_range.merge;
   return result;
 }
 
 Node* WasmGraphBuilder::Throw(Node* input) {
   MachineOperatorBuilder* machine = jsgraph()->machine();
 
   // Pass the thrown value as two SMIs:
   //
   // upper = static_cast<uint32_t>(input) >> 16;
   // lower = input & 0xFFFF;
   //
   // This is needed because we can't safely call BuildChangeInt32ToTagged from
   // this method.
   //
   // TODO(wasm): figure out how to properly pass this to the runtime function.
   Node* upper = BuildChangeInt32ToSmi(
       graph()->NewNode(machine->Word32Shr(), input, Int32Constant(16)));
   Node* lower = BuildChangeInt32ToSmi(
       graph()->NewNode(machine->Word32And(), input, Int32Constant(0xFFFFu)));
 
   Node* parameters[] = {lower, upper};  // thrown value
-  return BuildCallToRuntime(Runtime::kWasmThrow, jsgraph(), parameters,
-                            arraysize(parameters), effect_, control_);
+  return BuildCallToRuntime(Runtime::kWasmThrow, jsgraph(), centry_stub_node_,
+                            parameters, arraysize(parameters), effect_,
+                            control_);
 }
 
 Node* WasmGraphBuilder::Catch(Node* input, wasm::WasmCodePosition position) {
   CommonOperatorBuilder* common = jsgraph()->common();
 
   Node* parameters[] = {input};  // caught value
-  Node* value =
-      BuildCallToRuntime(Runtime::kWasmGetCaughtExceptionValue, jsgraph(),
-                         parameters, arraysize(parameters), effect_, control_);
+  Node* value = BuildCallToRuntime(Runtime::kWasmGetCaughtExceptionValue,
+                                   jsgraph(), centry_stub_node_, parameters,
+                                   arraysize(parameters), effect_, control_);
 
   Node* is_smi;
   Node* is_heap;
   BranchExpectFalse(BuildTestNotSmi(value), &is_heap, &is_smi);
 
   // is_smi
   Node* smi_i32 = BuildChangeSmiToInt32(value);
   Node* is_smi_effect = *effect_;
 
   // is_heap
@@ skipping 829 matching lines @@
   *control_ = start;
   *effect_ = start;
 
   // Create the context parameter
   Node* context = graph()->NewNode(
       jsgraph()->common()->Parameter(
           Linkage::GetJSCallContextParamIndex(wasm_count + 1), "%context"),
       graph()->start());
 
   // Set the ThreadInWasm flag before we do the actual call.
-  BuildModifyThreadInWasmFlag(true, jsgraph(), effect_, *control_);
+  BuildModifyThreadInWasmFlag(true, jsgraph(), centry_stub_node_, effect_,
+                              *control_);
 
   if (!wasm::IsJSCompatibleSignature(sig_)) {
     // Throw a TypeError. Use the context of the calling javascript function
     // (passed as a parameter), such that the generated code is context
     // independent.
     BuildCallToRuntimeWithContext(Runtime::kWasmThrowTypeError, jsgraph(),
-                                  context, nullptr, 0, effect_, control_);
+                                  centry_stub_node_, context, nullptr, 0,
+                                  effect_, control_);
 
     // Add a dummy call to the wasm function so that the generated wrapper
     // contains a reference to the wrapped wasm function. Without this reference
     // the wasm function could not be re-imported into another wasm module.
     int pos = 0;
     args[pos++] = HeapConstant(wasm_code);
     args[pos++] = *effect_;
     args[pos++] = *control_;
 
     // We only need a dummy call descriptor.
@@ skipping 19 matching lines @@
   args[pos++] = *control_;
 
   // Call the WASM code.
   CallDescriptor* desc =
       wasm::ModuleEnv::GetWasmCallDescriptor(jsgraph()->zone(), sig);
 
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc), count, args);
   *effect_ = call;
 
   // Clear the ThreadInWasmFlag
-  BuildModifyThreadInWasmFlag(false, jsgraph(), effect_, *control_);
+  BuildModifyThreadInWasmFlag(false, jsgraph(), centry_stub_node_, effect_,
+                              *control_);
 
   Node* retval = call;
   Node* jsval = ToJS(
       retval, sig->return_count() == 0 ? wasm::kWasmStmt : sig->GetReturn());
   Return(jsval);
 }
 
 int WasmGraphBuilder::AddParameterNodes(Node** args, int pos, int param_count,
                                         wasm::FunctionSig* sig) {
   // Convert WASM numbers to JS values.
@@ skipping 17 matching lines @@
   Node* start = Start(wasm_count + 3);
   *effect_ = start;
   *control_ = start;
 
   if (!wasm::IsJSCompatibleSignature(sig_)) {
     // Throw a TypeError. Embedding the context is ok here, since this code is
     // regenerated at instantiation time.
     Node* context =
         jsgraph()->HeapConstant(jsgraph()->isolate()->native_context());
     BuildCallToRuntimeWithContext(Runtime::kWasmThrowTypeError, jsgraph(),
-                                  context, nullptr, 0, effect_, control_);
+                                  centry_stub_node_, context, nullptr, 0,
+                                  effect_, control_);
     // We don't need to return a value here, as the runtime call will not return
     // anyway (the c entry stub will trigger stack unwinding).
     ReturnVoid();
     return;
   }
 
   Node** args = Buffer(wasm_count + 7);
 
   Node* call = nullptr;
 
-  BuildModifyThreadInWasmFlag(false, jsgraph(), effect_, *control_);
+  BuildModifyThreadInWasmFlag(false, jsgraph(), centry_stub_node_, effect_,
+                              *control_);
 
   if (target->IsJSFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(target);
     if (function->shared()->internal_formal_parameter_count() == wasm_count) {
       int pos = 0;
       args[pos++] = jsgraph()->Constant(target);  // target callable.
       // Receiver.
       if (is_sloppy(function->shared()->language_mode()) &&
           !function->shared()->native()) {
         args[pos++] =
@@ skipping 44 matching lines @@
     args[pos++] = HeapConstant(isolate->native_context());
     args[pos++] = *effect_;
     args[pos++] = *control_;
 
     call = graph()->NewNode(jsgraph()->common()->Call(desc), pos, args);
   }
 
   *effect_ = call;
   SetSourcePosition(call, 0);
 
-  BuildModifyThreadInWasmFlag(true, jsgraph(), effect_, *control_);
+  BuildModifyThreadInWasmFlag(true, jsgraph(), centry_stub_node_, effect_,
+                              *control_);
 
   // Convert the return value back.
   Node* val = sig->return_count() == 0
                   ? jsgraph()->Int32Constant(0)
                   : FromJS(call, HeapConstant(isolate->native_context()),
                            sig->GetReturn());
   Return(val);
 }
 
 void WasmGraphBuilder::BuildWasmInterpreterEntry(
@@ skipping 64 matching lines @@
   DCHECK_EQ(args_size_bytes, offset);
 
   // We are passing the raw arg_buffer here. To the GC and other parts, it looks
   // like a Smi (lowest bit not set). In the runtime function however, don't
   // call Smi::value on it, but just cast it to a byte pointer.
   Node* parameters[] = {
       jsgraph()->HeapConstant(instance),       // wasm instance
       jsgraph()->SmiConstant(function_index),  // function index
       arg_buffer,                              // argument buffer
   };
-  BuildCallToRuntime(Runtime::kWasmRunInterpreter, jsgraph(), parameters,
-                     arraysize(parameters), effect_, control_);
+  BuildCallToRuntime(Runtime::kWasmRunInterpreter, jsgraph(), centry_stub_node_,
+                     parameters, arraysize(parameters), effect_, control_);
 
   // Read back the return value.
   if (sig->return_count() == 0) {
     Return(Int32Constant(0));
   } else if (Int64Lowering::IsI64AsTwoParameters(jsgraph()->machine(),
                                                  sig->GetReturn())) {
     MachineType load_rep = wasm::WasmOpcodes::MachineTypeFor(wasm::kWasmI32);
     Node* lower =
         graph()->NewNode(jsgraph()->machine()->Load(load_rep), arg_buffer,
                          Int32Constant(kInt64LowerHalfMemoryOffset), *effect_,
@@ skipping 26 matching lines @@
   } else {
     return jsgraph()->RelocatableIntPtrConstant(
         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->get_origin());
-  DCHECK_NOT_NULL(module_);
-  DCHECK_NOT_NULL(module_->instance);
-  Node* call = BuildCallToRuntime(Runtime::kWasmMemorySize, jsgraph(), nullptr,
-                                  0, effect_, control_);
+  Node* call =
+      BuildCallToRuntime(Runtime::kWasmMemorySize, jsgraph(), centry_stub_node_,
+                         nullptr, 0, effect_, control_);
   Node* result = BuildChangeSmiToInt32(call);
   return result;
 }
 
 Node* WasmGraphBuilder::MemSize() {
   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);
@@ skipping 755 matching lines @@
   Zone zone(isolate->allocator(), ZONE_NAME);
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
   wasm::ModuleEnv module_env(module, nullptr);
-  WasmGraphBuilder builder(&module_env, &zone, &jsgraph, func->sig);
+  WasmGraphBuilder builder(&module_env, &zone, &jsgraph,
+                           CEntryStub(isolate, 1).GetCode(), func->sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.BuildJSToWasmWrapper(wasm_code, func->sig);
 
   //----------------------------------------------------------------------------
   // Run the compilation pipeline.
   //----------------------------------------------------------------------------
   if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
     OFStream os(stdout);
     os << "-- Graph after change lowering -- " << std::endl;
@@ skipping 58 matching lines @@
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
   SourcePositionTable* source_position_table =
       origin == wasm::kAsmJsOrigin ? new (&zone) SourcePositionTable(&graph)
                                    : nullptr;
 
-  WasmGraphBuilder builder(nullptr, &zone, &jsgraph, sig,
+  WasmGraphBuilder builder(nullptr, &zone, &jsgraph,
+                           CEntryStub(isolate, 1).GetCode(), sig,
                            source_position_table);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.BuildWasmToJSWrapper(target, sig);
 
   Handle<Code> code = Handle<Code>::null();
   {
     if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
       OFStream os(stdout);
       os << "-- Graph after change lowering -- " << std::endl;
@@ skipping 61 matching lines @@
   //----------------------------------------------------------------------------
   Zone zone(isolate->allocator(), ZONE_NAME);
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
-  WasmGraphBuilder builder(nullptr, &zone, &jsgraph, sig);
+  WasmGraphBuilder builder(nullptr, &zone, &jsgraph,
+                           CEntryStub(isolate, 1).GetCode(), sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.BuildWasmInterpreterEntry(func_index, sig, instance);
 
   Handle<Code> code = Handle<Code>::null();
   {
     if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
       OFStream os(stdout);
       os << "-- Wasm to interpreter graph -- " << std::endl;
       os << AsRPO(graph);
@@ skipping 44 matching lines @@
     decode_timer.Start();
   }
   // Create a TF graph during decoding.
 
   Graph* graph = jsgraph_->graph();
   CommonOperatorBuilder* common = jsgraph_->common();
   MachineOperatorBuilder* machine = jsgraph_->machine();
   SourcePositionTable* source_position_table =
       new (jsgraph_->zone()) SourcePositionTable(graph);
   WasmGraphBuilder builder(module_env_, jsgraph_->zone(), jsgraph_,
-                           func_body_.sig, source_position_table);
+                           centry_stub_, func_body_.sig, source_position_table);
   graph_construction_result_ =
       wasm::BuildTFGraph(isolate_->allocator(), &builder, func_body_);
 
   if (graph_construction_result_.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << graph_construction_result_.error_msg()
          << std::endl;
     }
     return nullptr;
@@ skipping 16 matching lines @@
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
   return source_position_table;
 }
 
 namespace {
 Vector<const char> GetDebugName(Zone* zone, wasm::WasmName name, int index) {
   if (!name.is_empty()) {
     return name;
   }
+#ifndef DEBUG
+  return {};
+#endif
   constexpr int kBufferLength = 15;
 
   EmbeddedVector<char, kBufferLength> name_vector;
   int name_len = SNPrintF(name_vector, "wasm#%d", index);
   DCHECK(name_len > 0 && name_len < name_vector.length());
 
   char* index_name = zone->NewArray<char>(name_len);
   memcpy(index_name, name_vector.start(), name_len);
   return Vector<const char>(index_name, name_len);
 }
@@ skipping 15 matching lines @@
 WasmCompilationUnit::WasmCompilationUnit(Isolate* isolate,
                                          wasm::ModuleEnv* module_env,
                                          wasm::FunctionBody body,
                                          wasm::WasmName name, int index,
                                          bool is_sync)
     : isolate_(isolate),
       module_env_(module_env),
       func_body_(body),
       func_name_(name),
       is_sync_(is_sync),
-      graph_zone_(new Zone(isolate->allocator(), ZONE_NAME)),
-      jsgraph_(new (graph_zone()) JSGraph(
-          isolate, new (graph_zone()) Graph(graph_zone()),
-          new (graph_zone()) CommonOperatorBuilder(graph_zone()), nullptr,
-          nullptr,
-          new (graph_zone()) MachineOperatorBuilder(
-              graph_zone(), MachineType::PointerRepresentation(),
-              InstructionSelector::SupportedMachineOperatorFlags(),
-              InstructionSelector::AlignmentRequirements()))),
-      compilation_zone_(isolate->allocator(), ZONE_NAME),
-      info_(GetDebugName(&compilation_zone_, name, index), isolate,
-            &compilation_zone_, Code::ComputeFlags(Code::WASM_FUNCTION)),
-      func_index_(index),
-      protected_instructions_(&compilation_zone_) {}
-
-void WasmCompilationUnit::InitializeHandles() {
-  // Create and cache this node in the main thread, which contains a handle to
-  // the code object of the c-entry stub.
-  jsgraph_->CEntryStubConstant(1);
-  DCHECK(!handles_initialized_);
-#if DEBUG
-  handles_initialized_ = true;
-#endif  // DEBUG
-}
+      centry_stub_(CEntryStub(isolate, 1).GetCode()),
+      func_index_(index) {}
 
 void WasmCompilationUnit::ExecuteCompilation() {
-  DCHECK(handles_initialized_);
   if (is_sync_) {
     // TODO(karlschimpf): Make this work when asynchronous.
     // https://bugs.chromium.org/p/v8/issues/detail?id=6361
     HistogramTimerScope wasm_compile_function_time_scope(
         isolate_->counters()->wasm_compile_function_time());
     ExecuteCompilationInternal();
-    return;
   }
   ExecuteCompilationInternal();
+  // Record the memory cost this unit places on the system until
+  // it is finalized. That may be "0" in error cases.
+  if (job_) {
+    size_t cost = job_->AllocatedMemory();
+    set_memory_cost(cost);
+  }
 }
 
 void WasmCompilationUnit::ExecuteCompilationInternal() {
   if (FLAG_trace_wasm_compiler) {
     if (func_name_.start() != nullptr) {
       PrintF("Compiling WASM function %d:'%.*s'\n\n", func_index(),
              func_name_.length(), func_name_.start());
     } else {
       PrintF("Compiling WASM function %d:<unnamed>\n\n", func_index());
     }
   }
 
   double decode_ms = 0;
   size_t node_count = 0;
 
-  std::unique_ptr<Zone> graph_zone(graph_zone_.release());
+  Zone graph_zone(isolate_->allocator(), ZONE_NAME);
+  jsgraph_ = new (&graph_zone) JSGraph(
+      isolate_, new (&graph_zone) Graph(&graph_zone),
+      new (&graph_zone) CommonOperatorBuilder(&graph_zone), nullptr, nullptr,
+      new (&graph_zone) MachineOperatorBuilder(
+          &graph_zone, MachineType::PointerRepresentation(),
+          InstructionSelector::SupportedMachineOperatorFlags(),
+          InstructionSelector::AlignmentRequirements()));
   SourcePositionTable* source_positions = BuildGraphForWasmFunction(&decode_ms);
 
   if (graph_construction_result_.failed()) {
     ok_ = false;
     return;
   }
 
   base::ElapsedTimer pipeline_timer;
   if (FLAG_trace_wasm_decode_time) {
     node_count = jsgraph_->graph()->NodeCount();
     pipeline_timer.Start();
   }
 
+  compilation_zone_.reset(new Zone(isolate_->allocator(), ZONE_NAME));
+
   // Run the compiler pipeline to generate machine code.
   CallDescriptor* descriptor = wasm::ModuleEnv::GetWasmCallDescriptor(
-      &compilation_zone_, func_body_.sig);
+      compilation_zone_.get(), func_body_.sig);
   if (jsgraph_->machine()->Is32()) {
-    descriptor =
-        module_env_->GetI32WasmCallDescriptor(&compilation_zone_, descriptor);
+    descriptor = module_env_->GetI32WasmCallDescriptor(compilation_zone_.get(),
+                                                       descriptor);
   }
+  info_.reset(new CompilationInfo(
+      GetDebugName(compilation_zone_.get(), func_name_, func_index_), isolate_,
+      compilation_zone_.get(), Code::ComputeFlags(Code::WASM_FUNCTION)));
+  ZoneVector<trap_handler::ProtectedInstructionData> protected_instructions(
+      compilation_zone_.get());
+
   job_.reset(Pipeline::NewWasmCompilationJob(
-      &info_, jsgraph_, descriptor, source_positions, &protected_instructions_,
-      !module_env_->module->is_wasm()));
+      info_.get(), jsgraph_, descriptor, source_positions,
+      &protected_instructions, !module_env_->module->is_wasm()));
   ok_ = job_->ExecuteJob() == CompilationJob::SUCCEEDED;
   // TODO(bradnelson): Improve histogram handling of size_t.
   if (is_sync_)
     // TODO(karlschimpf): Make this work when asynchronous.
     // https://bugs.chromium.org/p/v8/issues/detail?id=6361
     isolate_->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
         static_cast<int>(jsgraph_->graph()->zone()->allocation_size()));
 
   if (FLAG_trace_wasm_decode_time) {
     double pipeline_ms = pipeline_timer.Elapsed().InMillisecondsF();
     PrintF(
         "wasm-compilation phase 1 ok: %u bytes, %0.3f ms decode, %zu nodes, "
         "%0.3f ms pipeline\n",
         static_cast<unsigned>(func_body_.end - func_body_.start), decode_ms,
         node_count, pipeline_ms);
   }
+  // The graph zone is about to get out of scope. Avoid invalid references.
+  jsgraph_ = nullptr;
 }
 
 Handle<Code> WasmCompilationUnit::FinishCompilation(
     wasm::ErrorThrower* thrower) {
   if (!ok_) {
     if (graph_construction_result_.failed()) {
       // Add the function as another context for the exception
       ScopedVector<char> buffer(128);
       if (func_name_.start() == nullptr) {
         SNPrintF(buffer,
                  "Compiling WASM function #%d:%.*s failed:", func_index_,
                  func_name_.length(), func_name_.start());
       } else {
         SNPrintF(buffer, "Compiling WASM function #%d failed:", func_index_);
       }
       thrower->CompileFailed(buffer.start(), graph_construction_result_);
     }
 
     return Handle<Code>::null();
   }
   base::ElapsedTimer codegen_timer;
   if (FLAG_trace_wasm_decode_time) {
     codegen_timer.Start();
   }
   if (job_->FinalizeJob() != CompilationJob::SUCCEEDED) {
     return Handle<Code>::null();
   }
-  Handle<Code> code = info_.code();
+  Handle<Code> code = info_->code();
   DCHECK(!code.is_null());
 
   if (isolate_->logger()->is_logging_code_events() ||
       isolate_->is_profiling()) {
     RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, isolate_, code,
                               "WASM_function", func_index_,
                               wasm::WasmName("module"), func_name_);
   }
 
   if (FLAG_trace_wasm_decode_time) {
     double codegen_ms = codegen_timer.Elapsed().InMillisecondsF();
     PrintF("wasm-code-generation ok: %u bytes, %0.3f ms code generation\n",
            static_cast<unsigned>(func_body_.end - func_body_.start),
            codegen_ms);
   }
 
   return code;
 }
 
 // static
 Handle<Code> WasmCompilationUnit::CompileWasmFunction(
     wasm::ErrorThrower* thrower, Isolate* isolate,
     wasm::ModuleBytesEnv* module_env, const wasm::WasmFunction* function) {
   WasmCompilationUnit unit(isolate, module_env, function);
-  unit.InitializeHandles();
   unit.ExecuteCompilation();
   return unit.FinishCompilation(thrower);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8