df0cb9999f
Parser must be able to operate independent of Isolate and the V8 heap during parsing. After the heap-independent phase, there is a heap dependent phase, during which we internalize strings, handle errors, etc. This makes Isolate (also via CompilationInfo) unaccessible during parsing, and thus decreases the probability of accidental code changes which would add heap-dependent operations into the heap-independent phase. Since Isolate is also accessible via CompilationInfo, now CompilationInfo is only passed to the entry points of parsing, and not stored in Parser. R=rossberg@chromium.org BUG= Review URL: https://codereview.chromium.org/908173003 Cr-Commit-Position: refs/heads/master@{#26612}
69 lines
2.6 KiB
C++
69 lines
2.6 KiB
C++
// Copyright 2014 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/background-parsing-task.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
BackgroundParsingTask::BackgroundParsingTask(
|
|
StreamedSource* source, ScriptCompiler::CompileOptions options,
|
|
int stack_size, Isolate* isolate)
|
|
: source_(source), options_(options), stack_size_(stack_size) {
|
|
// Prepare the data for the internalization phase and compilation phase, which
|
|
// will happen in the main thread after parsing.
|
|
source->info.Reset(new i::CompilationInfoWithZone(source->source_stream.get(),
|
|
source->encoding, isolate));
|
|
source->info->MarkAsGlobal();
|
|
|
|
// We don't set the context to the CompilationInfo yet, because the background
|
|
// thread cannot do anything with it anyway. We set it just before compilation
|
|
// on the foreground thread.
|
|
DCHECK(options == ScriptCompiler::kProduceParserCache ||
|
|
options == ScriptCompiler::kProduceCodeCache ||
|
|
options == ScriptCompiler::kNoCompileOptions);
|
|
source->allow_lazy =
|
|
!i::Compiler::DebuggerWantsEagerCompilation(source->info.get());
|
|
|
|
if (!source->allow_lazy && options_ == ScriptCompiler::kProduceParserCache) {
|
|
// Producing cached data while parsing eagerly is not supported.
|
|
options_ = ScriptCompiler::kNoCompileOptions;
|
|
}
|
|
source->hash_seed = isolate->heap()->HashSeed();
|
|
}
|
|
|
|
|
|
void BackgroundParsingTask::Run() {
|
|
DisallowHeapAllocation no_allocation;
|
|
DisallowHandleAllocation no_handles;
|
|
DisallowHandleDereference no_deref;
|
|
|
|
ScriptData* script_data = NULL;
|
|
if (options_ == ScriptCompiler::kProduceParserCache ||
|
|
options_ == ScriptCompiler::kProduceCodeCache) {
|
|
source_->info->SetCachedData(&script_data, options_);
|
|
}
|
|
|
|
uintptr_t stack_limit =
|
|
reinterpret_cast<uintptr_t>(&stack_limit) - stack_size_ * KB;
|
|
|
|
// Parser needs to stay alive for finalizing the parsing on the main
|
|
// thread. Passing &parse_info is OK because Parser doesn't store it.
|
|
source_->parser.Reset(new Parser(source_->info.get(), stack_limit,
|
|
source_->hash_seed,
|
|
&source_->unicode_cache));
|
|
source_->parser->set_allow_lazy(source_->allow_lazy);
|
|
source_->parser->ParseOnBackground(source_->info.get());
|
|
|
|
if (script_data != NULL) {
|
|
source_->cached_data.Reset(new ScriptCompiler::CachedData(
|
|
script_data->data(), script_data->length(),
|
|
ScriptCompiler::CachedData::BufferOwned));
|
|
script_data->ReleaseDataOwnership();
|
|
delete script_data;
|
|
}
|
|
}
|
|
}
|
|
} // namespace v8::internal
|