Revert of [wasm] Implement parallel compilation.

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 214 matching lines @@
     Node* trap_reason_smi = builder_->BuildChangeInt32ToSmi(trap_reason_);
     Node* trap_position_smi = builder_->BuildChangeInt32ToSmi(trap_position_);
 
     if (module && !module->instance->context.is_null()) {
       // Use the module context to call the runtime to throw an exception.
       Runtime::FunctionId f = Runtime::kThrowWasmError;
       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);
       Node* inputs[] = {
           jsgraph()->CEntryStubConstant(fun->result_size),  // C entry
           trap_reason_smi,                                  // message id
           trap_position_smi,                                // byte position
           jsgraph()->ExternalConstant(
-              ExternalReference(f, jsgraph()->isolate())),    // ref
-          jsgraph()->Int32Constant(fun->nargs),               // arity
-          builder_->HeapConstant(module->instance->context),  // context
+              ExternalReference(f, jsgraph()->isolate())),  // ref
+          jsgraph()->Int32Constant(fun->nargs),             // arity
+          jsgraph()->Constant(module->instance->context),   // context
           *effect_ptr,
           *control_ptr};
 
       Node* node = graph()->NewNode(
           common()->Call(desc), static_cast<int>(arraysize(inputs)), inputs);
       *control_ptr = node;
       *effect_ptr = node;
     }
     if (false) {
       // End the control flow with a throw
@@ skipping 630 matching lines @@
 }
 
 Node* WasmGraphBuilder::Float32Constant(float value) {
   return jsgraph()->Float32Constant(value);
 }
 
 Node* WasmGraphBuilder::Float64Constant(double value) {
   return jsgraph()->Float64Constant(value);
 }
 
-Node* WasmGraphBuilder::HeapConstant(Handle<HeapObject> value) {
-  return jsgraph()->HeapConstant(value);
+Node* WasmGraphBuilder::Constant(Handle<Object> value) {
+  return jsgraph()->Constant(value);
 }
 
 Node* WasmGraphBuilder::Branch(Node* cond, Node** true_node,
                                Node** false_node) {
   DCHECK_NOT_NULL(cond);
   DCHECK_NOT_NULL(*control_);
   Node* branch =
       graph()->NewNode(jsgraph()->common()->Branch(), cond, *control_);
   *true_node = graph()->NewNode(jsgraph()->common()->IfTrue(), branch);
   *false_node = graph()->NewNode(jsgraph()->common()->IfFalse(), branch);
@@ skipping 981 matching lines @@
 
   *effect_ = call;
   return call;
 }
 
 Node* WasmGraphBuilder::CallDirect(uint32_t index, Node** args,
                                    wasm::WasmCodePosition position) {
   DCHECK_NULL(args[0]);
 
   // Add code object as constant.
-  args[0] = HeapConstant(module_->GetFunctionCode(index));
+  args[0] = Constant(module_->GetFunctionCode(index));
   wasm::FunctionSig* sig = module_->GetFunctionSignature(index);
 
   return BuildWasmCall(sig, args, position);
 }
 
 Node* WasmGraphBuilder::CallImport(uint32_t index, Node** args,
                                    wasm::WasmCodePosition position) {
   DCHECK_NULL(args[0]);
 
   // Add code object as constant.
-  args[0] = HeapConstant(module_->GetImportCode(index));
+  args[0] = Constant(module_->GetImportCode(index));
   wasm::FunctionSig* sig = module_->GetImportSignature(index);
 
   return BuildWasmCall(sig, args, position);
 }
 
 Node* WasmGraphBuilder::CallIndirect(uint32_t index, Node** args,
                                      wasm::WasmCodePosition position) {
   DCHECK_NOT_NULL(args[0]);
   DCHECK(module_ && module_->instance);
 
@@ skipping 457 matching lines @@
   Node* start = Start(param_count + 5);
   *control_ = start;
   *effect_ = start;
   // Create the context parameter
   Node* context = graph()->NewNode(
       jsgraph()->common()->Parameter(
           Linkage::GetJSCallContextParamIndex(wasm_count + 1), "%context"),
       graph()->start());
 
   int pos = 0;
-  args[pos++] = HeapConstant(wasm_code);
+  args[pos++] = Constant(wasm_code);
 
   // Convert JS parameters to WASM numbers.
   for (int i = 0; i < wasm_count; i++) {
     Node* param =
         graph()->NewNode(jsgraph()->common()->Parameter(i + 1), start);
     Node* wasm_param = FromJS(param, context, sig->GetParam(i));
     args[pos++] = wasm_param;
     if (jsgraph()->machine()->Is32() && sig->GetParam(i) == wasm::kAstI64) {
       // We make up the high word with SAR to get the proper sign extension.
       args[pos++] = graph()->NewNode(jsgraph()->machine()->Word32Sar(),
@@ skipping 37 matching lines @@
     param_count = Int64Lowering::GetParameterCountAfterLowering(sig);
   }
 
   // Build the start and the parameter nodes.
   Isolate* isolate = jsgraph()->isolate();
   CallDescriptor* desc;
   Node* start = Start(param_count + 3);
   *effect_ = start;
   *control_ = start;
   // JS context is the last parameter.
-  Node* context = HeapConstant(Handle<Context>(function->context(), isolate));
+  Node* context = Constant(Handle<Context>(function->context(), isolate));
   Node** args = Buffer(wasm_count + 7);
 
   bool arg_count_before_args = false;
   bool add_new_target_undefined = false;
 
   int pos = 0;
   if (js_count == wasm_count) {
     // exact arity match, just call the function directly.
     desc = Linkage::GetJSCallDescriptor(graph()->zone(), false, wasm_count + 1,
                                         CallDescriptor::kNoFlags);
@@ skipping 84 matching lines @@
     return mem_size_;
   } else {
     return jsgraph()->Int32Constant(size + offset);
   }
 }
 
 Node* WasmGraphBuilder::FunctionTable() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
   if (!function_table_) {
-    function_table_ = HeapConstant(module_->instance->function_table);
+    function_table_ = jsgraph()->Constant(module_->instance->function_table);
   }
   return function_table_;
 }
 
 Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
   DCHECK(module_ && module_->instance && module_->instance->globals_start);
   MachineType mem_type = module_->GetGlobalType(index);
   Node* addr = jsgraph()->IntPtrConstant(
       reinterpret_cast<uintptr_t>(module_->instance->globals_start +
                                   module_->module->globals[index].offset));
@@ skipping 319 matching lines @@
       buffer.Dispose();
     }
 
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "wasm-to-js", 0,
                               module_name);
   }
   return code;
 }
 
 std::pair<JSGraph*, SourcePositionTable*> BuildGraphForWasmFunction(
-    JSGraph* jsgraph, wasm::ErrorThrower* thrower, Isolate* isolate,
+    Zone* zone, wasm::ErrorThrower* thrower, Isolate* isolate,
     wasm::ModuleEnv*& module_env, const wasm::WasmFunction* function,
     double* decode_ms) {
   base::ElapsedTimer decode_timer;
   if (FLAG_trace_wasm_decode_time) {
     decode_timer.Start();
   }
   // Create a TF graph during decoding.
-  Graph* graph = jsgraph->graph();
-  CommonOperatorBuilder* common = jsgraph->common();
-  MachineOperatorBuilder* machine = jsgraph->machine();
+  Graph* graph = new (zone) Graph(zone);
+  CommonOperatorBuilder* common = new (zone) CommonOperatorBuilder(zone);
+  MachineOperatorBuilder* machine = new (zone) MachineOperatorBuilder(
+      zone, MachineType::PointerRepresentation(),
+      InstructionSelector::SupportedMachineOperatorFlags());
+  JSGraph* jsgraph =
+      new (zone) JSGraph(isolate, graph, common, nullptr, nullptr, machine);
   SourcePositionTable* source_position_table =
-      new (jsgraph->zone()) SourcePositionTable(graph);
-  WasmGraphBuilder builder(jsgraph->zone(), jsgraph, function->sig,
-                           source_position_table);
+      new (zone) SourcePositionTable(graph);
+  WasmGraphBuilder builder(zone, jsgraph, function->sig, source_position_table);
   wasm::FunctionBody body = {
       module_env, function->sig, module_env->module->module_start,
       module_env->module->module_start + function->code_start_offset,
       module_env->module->module_start + function->code_end_offset};
   wasm::TreeResult result =
       wasm::BuildTFGraph(isolate->allocator(), &builder, body);
 
   if (machine->Is32()) {
-    Int64Lowering r(graph, machine, common, jsgraph->zone(), function->sig);
+    Int64Lowering r(graph, machine, common, zone, function->sig);
     r.LowerGraph();
   }
 
   if (result.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << result << std::endl;
     }
     // Add the function as another context for the exception
     ScopedVector<char> buffer(128);
@@ skipping 16 matching lines @@
 
 class WasmCompilationUnit {
  public:
   WasmCompilationUnit(wasm::ErrorThrower* thrower, Isolate* isolate,
                       wasm::ModuleEnv* module_env,
                       const wasm::WasmFunction* function, uint32_t index)
       : thrower_(thrower),
         isolate_(isolate),
         module_env_(module_env),
         function_(function),
-        graph_zone_(new Zone(isolate->allocator())),
-        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()))),
         compilation_zone_(isolate->allocator()),
         info_(function->name_length != 0
                   ? module_env->module->GetNameOrNull(function->name_offset,
                                                       function->name_length)
                   : ArrayVector("wasm"),
               isolate, &compilation_zone_,
               Code::ComputeFlags(Code::WASM_FUNCTION)),
         job_(),
         index_(index),
-        ok_(true) {
-    // Create and cache this node in the main thread.
-    jsgraph_->CEntryStubConstant(1);
-  }
-
-  Zone* graph_zone() { return graph_zone_.get(); }
+        ok_(true) {}
 
   void ExecuteCompilation() {
     HistogramTimerScope wasm_compile_function_time_scope(
         isolate_->counters()->wasm_compile_function_time());
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compiling WASM function "
          << wasm::WasmFunctionName(function_, module_env_) << std::endl;
       os << std::endl;
     }
 
     double decode_ms = 0;
     size_t node_count = 0;
 
-    base::SmartPointer<Zone> graph_zone(graph_zone_.Detach());
+    Zone zone(isolate_->allocator());
     std::pair<JSGraph*, SourcePositionTable*> graph_result =
-        BuildGraphForWasmFunction(jsgraph_, thrower_, isolate_, module_env_,
+        BuildGraphForWasmFunction(&zone, thrower_, isolate_, module_env_,
                                   function_, &decode_ms);
     JSGraph* jsgraph = graph_result.first;
     SourcePositionTable* source_positions = graph_result.second;
 
     if (jsgraph == nullptr) {
       ok_ = false;
       return;
     }
 
     base::ElapsedTimer pipeline_timer;
@@ skipping 64 matching lines @@
              compile_ms);
     }
 
     return code;
   }
 
   wasm::ErrorThrower* thrower_;
   Isolate* isolate_;
   wasm::ModuleEnv* module_env_;
   const wasm::WasmFunction* function_;
-  // The graph zone is deallocated at the end of ExecuteCompilation.
-  base::SmartPointer<Zone> graph_zone_;
-  JSGraph* jsgraph_;
   Zone compilation_zone_;
   CompilationInfo info_;
   base::SmartPointer<CompilationJob> job_;
   uint32_t index_;
   bool ok_;
 };
 
 WasmCompilationUnit* CreateWasmCompilationUnit(
     wasm::ErrorThrower* thrower, Isolate* isolate, wasm::ModuleEnv* module_env,
     const wasm::WasmFunction* function, uint32_t index) {
@@ skipping 20 matching lines @@
                                  const wasm::WasmFunction* function) {
   WasmCompilationUnit* unit =
       CreateWasmCompilationUnit(thrower, isolate, module_env, function, 0);
   ExecuteCompilation(unit);
   return FinishCompilation(unit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8