Revert of [Compiler] Enable handles created during parsing and scope analysis to be deferred.

src/compiler.cc

 // Copyright 2012 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.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 21 matching lines @@
 #include "src/parsing/parsing.h"
 #include "src/parsing/rewriter.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/runtime-profiler.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
-// A wrapper around a ParseInfo that detaches the parser handles from the
-// underlying DeferredHandleScope and stores them in info_ on destruction.
-class ParseHandleScope final {
- public:
-  explicit ParseHandleScope(ParseInfo* info)
-      : deferred_(info->isolate()), info_(info) {}
-  ~ParseHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }
-
- private:
-  DeferredHandleScope deferred_;
-  ParseInfo* info_;
-};
-
 // A wrapper around a CompilationInfo that detaches the Handles from
 // the underlying DeferredHandleScope and stores them in info_ on
 // destruction.
 class CompilationHandleScope final {
  public:
   explicit CompilationHandleScope(CompilationInfo* info)
       : deferred_(info->isolate()), info_(info) {}
   ~CompilationHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }
 
  private:
@@ skipping 453 matching lines @@
   if (FinalizeUnoptimizedCompilationJob(job.get()) !=
       CompilationJob::SUCCEEDED) {
     return false;
   }
   return true;
 }
 
 bool CompileUnoptimizedInnerFunctions(
     Compiler::EagerInnerFunctionLiterals* literals,
     Compiler::ConcurrencyMode inner_function_mode,
-    std::shared_ptr<Zone> parse_zone, CompilationInfo* outer_info) {
+    CompilationInfo* outer_info) {
   Isolate* isolate = outer_info->isolate();
   Handle<Script> script = outer_info->script();
   bool is_debug = outer_info->is_debug();
   bool will_serialize = outer_info->will_serialize();
   RuntimeCallTimerScope runtimeTimer(isolate,
                                      &RuntimeCallStats::CompileInnerFunction);
 
   for (auto it : *literals) {
     FunctionLiteral* literal = it->value();
     Handle<SharedFunctionInfo> shared =
         Compiler::GetSharedFunctionInfo(literal, script, outer_info);
     if (shared->is_compiled()) continue;
 
     // The {literal} has already been numbered because AstNumbering decends into
     // eagerly compiled function literals.
     SetSharedFunctionFlagsFromLiteral(literal, shared);
 
     // Try to enqueue the eager function on the compiler dispatcher.
     CompilerDispatcher* dispatcher = isolate->compiler_dispatcher();
     if (UseCompilerDispatcher(inner_function_mode, dispatcher, literal->scope(),
                               shared, is_debug, will_serialize) &&
-        dispatcher->EnqueueAndStep(shared, literal, parse_zone,
-                                   outer_info->parse_info()->deferred_handles(),
-                                   outer_info->deferred_handles())) {
+        dispatcher->EnqueueAndStep(shared, literal)) {
       // If we have successfully queued up the function for compilation on the
       // compiler dispatcher then we are done.
       continue;
     } else {
       // Otherwise generate unoptimized code now.
       ParseInfo parse_info(script);
       CompilationInfo info(parse_info.zone(), &parse_info,
                            Handle<JSFunction>::null());
 
       parse_info.set_literal(literal);
@@ skipping 24 matching lines @@
   }
   return false;
 }
 
 bool CompileUnoptimizedCode(CompilationInfo* info,
                             Compiler::ConcurrencyMode inner_function_mode) {
   Isolate* isolate = info->isolate();
   DCHECK(AllowCompilation::IsAllowed(isolate));
 
   Compiler::EagerInnerFunctionLiterals inner_literals;
-  {
-    std::unique_ptr<CompilationHandleScope> compilation_handle_scope;
-    if (inner_function_mode == Compiler::CONCURRENT) {
-      compilation_handle_scope.reset(new CompilationHandleScope(info));
-    }
-    if (!Compiler::Analyze(info->parse_info(), &inner_literals)) {
-      if (!isolate->has_pending_exception()) isolate->StackOverflow();
-      return false;
-    }
+  if (!Compiler::Analyze(info->parse_info(), &inner_literals)) {
+    if (!isolate->has_pending_exception()) isolate->StackOverflow();
+    return false;
   }
 
   // Disable concurrent inner compilation for asm-wasm code.
   // TODO(rmcilroy,bradnelson): Remove this AsmWasm check once the asm-wasm
   // builder doesn't do parsing when visiting function declarations.
   if (info->scope()->IsAsmModule() ||
       InnerFunctionIsAsmModule(&inner_literals)) {
     inner_function_mode = Compiler::NOT_CONCURRENT;
   }
 
-  std::shared_ptr<Zone> parse_zone;
   if (inner_function_mode == Compiler::CONCURRENT) {
     // Seal the parse zone so that it can be shared by parallel inner function
     // compilation jobs.
     DCHECK_NE(info->parse_info()->zone(), info->zone());
-    parse_zone = info->parse_info()->zone_shared();
-    parse_zone->Seal();
+    info->parse_info()->zone()->Seal();
   }
 
   if (!CompileUnoptimizedInnerFunctions(&inner_literals, inner_function_mode,
-                                        parse_zone, info) ||
+                                        info) ||
       !GenerateUnoptimizedCode(info)) {
     if (!isolate->has_pending_exception()) isolate->StackOverflow();
     return false;
   }
 
   // TODO(rmcilroy): Remove this once the enqueued tasks can keep the parsed
   // zone and handles alive and replace with a check in CompileLazy to finish
   // the task itself.
   RuntimeCallTimerScope runtimeTimer(
       isolate, &RuntimeCallStats::CompileWaitForDispatcher);
@@ skipping 20 matching lines @@
   info->script()->set_shared_function_infos(*infos);
 }
 
 MUST_USE_RESULT MaybeHandle<Code> GetUnoptimizedCode(
     CompilationInfo* info, Compiler::ConcurrencyMode inner_function_mode) {
   RuntimeCallTimerScope runtimeTimer(
       info->isolate(), &RuntimeCallStats::CompileGetUnoptimizedCode);
   VMState<COMPILER> state(info->isolate());
   PostponeInterruptsScope postpone(info->isolate());
 
-  // Parse and update ParseInfo with the results.
-  {
-    if (!parsing::ParseAny(info->parse_info(),
-                           inner_function_mode != Compiler::CONCURRENT)) {
-      return MaybeHandle<Code>();
-    }
-
-    if (inner_function_mode == Compiler::CONCURRENT) {
-      ParseHandleScope parse_handles(info->parse_info());
-      info->parse_info()->ReopenHandlesInNewHandleScope();
-      info->parse_info()->ast_value_factory()->Internalize(info->isolate());
-    }
-  }
-
+  // Parse and update CompilationInfo with the results.
+  if (!parsing::ParseAny(info->parse_info())) return MaybeHandle<Code>();
   if (info->parse_info()->is_toplevel()) {
     EnsureSharedFunctionInfosArrayOnScript(info->parse_info());
   }
   DCHECK_EQ(info->shared_info()->language_mode(),
             info->literal()->language_mode());
 
   // Compile either unoptimized code or bytecode for the interpreter.
   if (!CompileUnoptimizedCode(info, inner_function_mode)) {
     return MaybeHandle<Code>();
   }
@@ skipping 471 matching lines @@
 
   Handle<Script> script = parse_info->script();
 
   // TODO(svenpanne) Obscure place for this, perhaps move to OnBeforeCompile?
   FixedArray* array = isolate->native_context()->embedder_data();
   script->set_context_data(array->get(v8::Context::kDebugIdIndex));
 
   Handle<SharedFunctionInfo> result;
 
   { VMState<COMPILER> state(info->isolate());
-    if (parse_info->literal() == nullptr) {
-      if (!parsing::ParseProgram(parse_info, false)) {
-        return Handle<SharedFunctionInfo>::null();
-      }
-
-      {
-        ParseHandleScope parse_handles(parse_info);
-        parse_info->ReopenHandlesInNewHandleScope();
-        parse_info->ast_value_factory()->Internalize(info->isolate());
-      }
+    if (parse_info->literal() == nullptr &&
+        !parsing::ParseProgram(parse_info)) {
+      return Handle<SharedFunctionInfo>::null();
     }
 
     EnsureSharedFunctionInfosArrayOnScript(parse_info);
 
     // Measure how long it takes to do the compilation; only take the
     // rest of the function into account to avoid overlap with the
     // parsing statistics.
     HistogramTimer* rate = parse_info->is_eval()
                                ? info->isolate()->counters()->compile_eval()
                                : info->isolate()->counters()->compile();
@@ skipping 719 matching lines @@
   }
 
   if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8