blob: dd980bfa41cf64e0ca48abe0ba7faa658bf6a344 [file] [log] [blame]
// Copyright 2022 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/maglev/maglev-compilation-info.h"
#include "src/compiler/compilation-dependencies.h"
#include "src/compiler/js-heap-broker.h"
#include "src/execution/isolate.h"
#include "src/flags/flags.h"
#include "src/handles/persistent-handles.h"
#include "src/maglev/maglev-code-generator.h"
#include "src/maglev/maglev-compilation-unit.h"
#include "src/maglev/maglev-concurrent-dispatcher.h"
#include "src/maglev/maglev-graph-labeller.h"
#include "src/objects/js-function-inl.h"
#include "src/utils/identity-map.h"
namespace v8 {
namespace internal {
namespace maglev {
namespace {
constexpr char kMaglevZoneName[] = "maglev-compilation-job-zone";
class V8_NODISCARD MaglevCompilationHandleScope final {
public:
MaglevCompilationHandleScope(Isolate* isolate,
maglev::MaglevCompilationInfo* info)
: info_(info), persistent_(isolate), exported_info_(info) {
info->ReopenAndCanonicalizeHandlesInNewScope(isolate);
}
~MaglevCompilationHandleScope() {
info_->set_persistent_handles(persistent_.Detach());
}
private:
maglev::MaglevCompilationInfo* const info_;
PersistentHandlesScope persistent_;
ExportedMaglevCompilationInfo exported_info_;
};
} // namespace
MaglevCompilationInfo::MaglevCompilationInfo(Isolate* isolate,
Handle<JSFunction> function,
BytecodeOffset osr_offset)
: zone_(isolate->allocator(), kMaglevZoneName),
broker_(new compiler::JSHeapBroker(
isolate, zone(), v8_flags.trace_heap_broker, CodeKind::MAGLEV)),
toplevel_function_(function),
osr_offset_(osr_offset)
#define V(Name) , Name##_(v8_flags.Name)
MAGLEV_COMPILATION_FLAG_LIST(V)
#undef V
,
specialize_to_function_context_(
osr_offset == BytecodeOffset::None() &&
v8_flags.maglev_function_context_specialization &&
function->raw_feedback_cell().map() ==
ReadOnlyRoots(isolate).one_closure_cell_map()) {
DCHECK(v8_flags.maglev);
DCHECK_IMPLIES(osr_offset != BytecodeOffset::None(), v8_flags.maglev_osr);
canonical_handles_ = std::make_unique<CanonicalHandlesMap>(
isolate->heap(), ZoneAllocationPolicy(&zone_));
compiler::CurrentHeapBrokerScope current_broker(broker_.get());
collect_source_positions_ = isolate->NeedsDetailedOptimizedCodeLineInfo();
if (collect_source_positions_) {
SharedFunctionInfo::EnsureSourcePositionsAvailable(
isolate, handle(function->shared(), isolate));
}
MaglevCompilationHandleScope compilation(isolate, this);
compiler::CompilationDependencies* deps =
zone()->New<compiler::CompilationDependencies>(broker(), zone());
USE(deps); // The deps register themselves in the heap broker.
broker()->AttachCompilationInfo(this);
// Heap broker initialization may already use IsPendingAllocation.
isolate->heap()->PublishPendingAllocations();
broker()->InitializeAndStartSerializing(
handle(function->native_context(), isolate));
broker()->StopSerializing();
// Serialization may have allocated.
isolate->heap()->PublishPendingAllocations();
toplevel_compilation_unit_ =
MaglevCompilationUnit::New(zone(), this, function);
}
MaglevCompilationInfo::~MaglevCompilationInfo() = default;
void MaglevCompilationInfo::set_graph_labeller(
MaglevGraphLabeller* graph_labeller) {
graph_labeller_.reset(graph_labeller);
}
void MaglevCompilationInfo::set_code_generator(
std::unique_ptr<MaglevCodeGenerator> code_generator) {
code_generator_ = std::move(code_generator);
}
namespace {
template <typename T>
Handle<T> CanonicalHandle(CanonicalHandlesMap* canonical_handles, T object,
Isolate* isolate) {
DCHECK_NOT_NULL(canonical_handles);
DCHECK(PersistentHandlesScope::IsActive(isolate));
auto find_result = canonical_handles->FindOrInsert(object);
if (!find_result.already_exists) {
*find_result.entry = Handle<T>(object, isolate).location();
}
return Handle<T>(*find_result.entry);
}
} // namespace
void MaglevCompilationInfo::ReopenAndCanonicalizeHandlesInNewScope(
Isolate* isolate) {
toplevel_function_ =
CanonicalHandle(canonical_handles_.get(), *toplevel_function_, isolate);
}
void MaglevCompilationInfo::set_persistent_handles(
std::unique_ptr<PersistentHandles>&& persistent_handles) {
DCHECK_NULL(ph_);
ph_ = std::move(persistent_handles);
DCHECK_NOT_NULL(ph_);
}
std::unique_ptr<PersistentHandles>
MaglevCompilationInfo::DetachPersistentHandles() {
DCHECK_NOT_NULL(ph_);
return std::move(ph_);
}
void MaglevCompilationInfo::set_canonical_handles(
std::unique_ptr<CanonicalHandlesMap>&& canonical_handles) {
DCHECK_NULL(canonical_handles_);
canonical_handles_ = std::move(canonical_handles);
DCHECK_NOT_NULL(canonical_handles_);
}
std::unique_ptr<CanonicalHandlesMap>
MaglevCompilationInfo::DetachCanonicalHandles() {
DCHECK_NOT_NULL(canonical_handles_);
return std::move(canonical_handles_);
}
} // namespace maglev
} // namespace internal
} // namespace v8