// 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/api/api.h"

#include <algorithm> // For min

#include <cmath> // For isnan.

#include <limits>

#include <sstream>

#include <string>

#include <utility> // For move

#include <vector>

#include "include/v8-callbacks.h"

#include "include/v8-cppgc.h"

#include "include/v8-date.h"

#include "include/v8-embedder-state-scope.h"

#include "include/v8-extension.h"

#include "include/v8-fast-api-calls.h"

#include "include/v8-function.h"

#include "include/v8-json.h"

#include "include/v8-locker.h"

#include "include/v8-primitive-object.h"

#include "include/v8-profiler.h"

#include "include/v8-unwinder-state.h"

#include "include/v8-util.h"

#include "include/v8-wasm.h"

#include "src/api/api-inl.h"

#include "src/api/api-natives.h"

#include "src/base/functional.h"

#include "src/base/logging.h"

#include "src/base/platform/memory.h"

#include "src/base/platform/platform.h"

#include "src/base/platform/time.h"

#include "src/base/safe_conversions.h"

#include "src/base/utils/random-number-generator.h"

#include "src/baseline/baseline-batch-compiler.h"

#include "src/builtins/accessors.h"

#include "src/builtins/builtins-utils.h"

#include "src/codegen/compiler.h"

#include "src/codegen/cpu-features.h"

#include "src/codegen/script-details.h"

#include "src/common/assert-scope.h"

#include "src/common/globals.h"

#include "src/compiler-dispatcher/lazy-compile-dispatcher.h"

#include "src/date/date.h"

#include "src/objects/primitive-heap-object.h"

#if V8_ENABLE_WEBASSEMBLY

#include "src/debug/debug-wasm-objects.h"

#endif // V8_ENABLE_WEBASSEMBLY

#include "src/debug/liveedit.h"

#include "src/deoptimizer/deoptimizer.h"

#include "src/execution/embedder-state.h"

#include "src/execution/execution.h"

#include "src/execution/frames-inl.h"

#include "src/execution/isolate-inl.h"

#include "src/execution/messages.h"

#include "src/execution/microtask-queue.h"

#include "src/execution/simulator.h"

#include "src/execution/v8threads.h"

#include "src/execution/vm-state-inl.h"

#include "src/handles/global-handles.h"

#include "src/handles/persistent-handles.h"

#include "src/handles/shared-object-conveyor-handles.h"

#include "src/handles/traced-handles.h"

#include "src/heap/embedder-tracing.h"

#include "src/heap/heap-inl.h"

#include "src/heap/heap-write-barrier.h"

#include "src/heap/safepoint.h"

#include "src/init/bootstrapper.h"

#include "src/init/icu_util.h"

#include "src/init/startup-data-util.h"

#include "src/init/v8.h"

#include "src/json/json-parser.h"

#include "src/json/json-stringifier.h"

#include "src/logging/counters-scopes.h"

#include "src/logging/metrics.h"

#include "src/logging/runtime-call-stats-scope.h"

#include "src/logging/tracing-flags.h"

#include "src/numbers/conversions-inl.h"

#include "src/objects/api-callbacks.h"

#include "src/objects/contexts.h"

#include "src/objects/embedder-data-array-inl.h"

#include "src/objects/embedder-data-slot-inl.h"

#include "src/objects/hash-table-inl.h"

#include "src/objects/heap-object.h"

#include "src/objects/js-array-buffer-inl.h"

#include "src/objects/js-array-inl.h"

#include "src/objects/js-collection-inl.h"

#include "src/objects/js-promise-inl.h"

#include "src/objects/js-regexp-inl.h"

#include "src/objects/js-weak-refs-inl.h"

#include "src/objects/module-inl.h"

#include "src/objects/objects-inl.h"

#include "src/objects/oddball.h"

#include "src/objects/ordered-hash-table-inl.h"

#include "src/objects/property-descriptor.h"

#include "src/objects/property-details.h"

#include "src/objects/property.h"

#include "src/objects/prototype.h"

#include "src/objects/shared-function-info.h"

#include "src/objects/slots.h"

#include "src/objects/smi.h"

#include "src/objects/synthetic-module-inl.h"

#include "src/objects/templates.h"

#include "src/objects/value-serializer.h"

#include "src/parsing/parse-info.h"

#include "src/parsing/parser.h"

#include "src/parsing/pending-compilation-error-handler.h"

#include "src/parsing/scanner-character-streams.h"

#include "src/profiler/cpu-profiler.h"

#include "src/profiler/heap-profiler.h"

#include "src/profiler/heap-snapshot-generator-inl.h"

#include "src/profiler/profile-generator-inl.h"

#include "src/profiler/tick-sample.h"

#include "src/regexp/regexp-utils.h"

#include "src/runtime/runtime.h"

#include "src/sandbox/external-pointer.h"

#include "src/sandbox/sandbox.h"

#include "src/snapshot/code-serializer.h"

#include "src/snapshot/embedded/embedded-data.h"

#include "src/snapshot/snapshot.h"

#include "src/snapshot/startup-serializer.h" // For SerializedHandleChecker.

#include "src/strings/char-predicates-inl.h"

#include "src/strings/string-hasher.h"

#include "src/strings/unicode-inl.h"

#include "src/tracing/trace-event.h"

#include "src/utils/detachable-vector.h"

#include "src/utils/version.h"

#include "src/web-snapshot/web-snapshot.h"

#if V8_ENABLE_WEBASSEMBLY

#include "src/trap-handler/trap-handler.h"

#include "src/wasm/streaming-decoder.h"

#include "src/wasm/value-type.h"

#include "src/wasm/wasm-engine.h"

#include "src/wasm/wasm-js.h"

#include "src/wasm/wasm-objects-inl.h"

#include "src/wasm/wasm-result.h"

#include "src/wasm/wasm-serialization.h"

#endif // V8_ENABLE_WEBASSEMBLY

#if V8_OS_LINUX || V8_OS_DARWIN || V8_OS_FREEBSD

#include <signal.h>

#if V8_ENABLE_WEBASSEMBLY

#include "include/v8-wasm-trap-handler-posix.h"

#include "src/trap-handler/handler-inside-posix.h"

#endif // V8_ENABLE_WEBASSEMBLY

#endif // V8_OS_LINUX || V8_OS_DARWIN || V8_OS_FREEBSD

#if V8_OS_WIN

#include <windows.h>

// This has to come after windows.h.

#include <versionhelpers.h>

#include "include/v8-wasm-trap-handler-win.h"

#include "src/trap-handler/handler-inside-win.h"

#if defined(V8_OS_WIN64)

#include "src/base/platform/wrappers.h"

#include "src/diagnostics/unwinding-info-win64.h"

#endif // V8_OS_WIN64

#endif // V8_OS_WIN

#if defined(V8_OS_WIN) && defined(V8_ENABLE_ETW_STACK_WALKING)

#include "src/diagnostics/etw-jit-win.h"

#endif

// Has to be the last include (doesn't have include guards):

#include "src/api/api-macros.h"

namespace v8 {

static OOMErrorCallback g_oom_error_callback = nullptr;

static ScriptOrigin GetScriptOriginForScript(i::Isolate* i_isolate,

i::Handle<i::Script> script) {

i::Handle<i::Object> scriptName(script->GetNameOrSourceURL(), i_isolate);

i::Handle<i::Object> source_map_url(script->source_mapping_url(), i_isolate);

i::Handle<i::Object> host_defined_options(script->host_defined_options(),

i_isolate);

ScriptOriginOptions options(script->origin_options());

bool is_wasm = false;

#if V8_ENABLE_WEBASSEMBLY

is_wasm = script->type() == i::Script::TYPE_WASM;

#endif // V8_ENABLE_WEBASSEMBLY

v8::ScriptOrigin origin(

reinterpret_cast<v8::Isolate*>(i_isolate), Utils::ToLocal(scriptName),

script->line_offset(), script->column_offset(),

options.IsSharedCrossOrigin(), script->id(),

Utils::ToLocal(source_map_url), options.IsOpaque(), is_wasm,

options.IsModule(), Utils::ToLocal(host_defined_options));

return origin;

}

// --- E x c e p t i o n B e h a v i o r ---

// When V8 cannot allocate memory FatalProcessOutOfMemory is called. The default

// OOM error handler is called and execution is stopped.

void i::V8::FatalProcessOutOfMemory(i::Isolate* i_isolate, const char* location,

const OOMDetails& details) {

char last_few_messages[Heap::kTraceRingBufferSize + 1];

char js_stacktrace[Heap::kStacktraceBufferSize + 1];

i::HeapStats heap_stats;

if (i_isolate == nullptr) {

i_isolate = Isolate::TryGetCurrent();

}

if (i_isolate == nullptr) {

// If the Isolate is not available for the current thread we cannot retrieve

// memory information from the Isolate. Write easy-to-recognize values on

// the stack.

memset(last_few_messages, 0x0BADC0DE, Heap::kTraceRingBufferSize + 1);

memset(js_stacktrace, 0x0BADC0DE, Heap::kStacktraceBufferSize + 1);

memset(&heap_stats, 0xBADC0DE, sizeof(heap_stats));

// Give the embedder a chance to handle the condition. If it doesn't,

// just crash.

if (g_oom_error_callback) g_oom_error_callback(location, details);

FATAL("Fatal process out of memory: %s", location);

UNREACHABLE();

}

memset(last_few_messages, 0, Heap::kTraceRingBufferSize + 1);

memset(js_stacktrace, 0, Heap::kStacktraceBufferSize + 1);

intptr_t start_marker;

heap_stats.start_marker = &start_marker;

size_t ro_space_size;

heap_stats.ro_space_size = &ro_space_size;

size_t ro_space_capacity;

heap_stats.ro_space_capacity = &ro_space_capacity;

size_t new_space_size;

heap_stats.new_space_size = &new_space_size;

size_t new_space_capacity;

heap_stats.new_space_capacity = &new_space_capacity;

size_t old_space_size;

heap_stats.old_space_size = &old_space_size;

size_t old_space_capacity;

heap_stats.old_space_capacity = &old_space_capacity;

size_t code_space_size;

heap_stats.code_space_size = &code_space_size;

size_t code_space_capacity;

heap_stats.code_space_capacity = &code_space_capacity;

size_t map_space_size;

heap_stats.map_space_size = &map_space_size;

size_t map_space_capacity;

heap_stats.map_space_capacity = &map_space_capacity;

size_t lo_space_size;

heap_stats.lo_space_size = &lo_space_size;

size_t code_lo_space_size;

heap_stats.code_lo_space_size = &code_lo_space_size;

size_t global_handle_count;

heap_stats.global_handle_count = &global_handle_count;

size_t weak_global_handle_count;

heap_stats.weak_global_handle_count = &weak_global_handle_count;

size_t pending_global_handle_count;

heap_stats.pending_global_handle_count = &pending_global_handle_count;

size_t near_death_global_handle_count;

heap_stats.near_death_global_handle_count = &near_death_global_handle_count;

size_t free_global_handle_count;

heap_stats.free_global_handle_count = &free_global_handle_count;

size_t memory_allocator_size;

heap_stats.memory_allocator_size = &memory_allocator_size;

size_t memory_allocator_capacity;

heap_stats.memory_allocator_capacity = &memory_allocator_capacity;

size_t malloced_memory;

heap_stats.malloced_memory = &malloced_memory;

size_t malloced_peak_memory;

heap_stats.malloced_peak_memory = &malloced_peak_memory;

size_t objects_per_type[LAST_TYPE + 1] = {0};

heap_stats.objects_per_type = objects_per_type;

size_t size_per_type[LAST_TYPE + 1] = {0};

heap_stats.size_per_type = size_per_type;

int os_error;

heap_stats.os_error = &os_error;

heap_stats.last_few_messages = last_few_messages;

heap_stats.js_stacktrace = js_stacktrace;

intptr_t end_marker;

heap_stats.end_marker = &end_marker;

if (i_isolate->heap()->HasBeenSetUp()) {

// BUG(1718): Don't use the take_snapshot since we don't support

// HeapObjectIterator here without doing a special GC.

i_isolate->heap()->RecordStats(&heap_stats, false);

if (!v8_flags.correctness_fuzzer_suppressions) {

char* first_newline = strchr(last_few_messages, '\n');

if (first_newline == nullptr || first_newline[1] == '\0')

first_newline = last_few_messages;

base::OS::PrintError("\n<--- Last few GCs --->\n%s\n", first_newline);

base::OS::PrintError("\n<--- JS stacktrace --->\n%s\n", js_stacktrace);

}

}

Utils::ReportOOMFailure(i_isolate, location, details);

if (g_oom_error_callback) g_oom_error_callback(location, details);

// If the fatal error handler returns, we stop execution.

FATAL("API fatal error handler returned after process out of memory");

}

void i::V8::FatalProcessOutOfMemory(i::Isolate* i_isolate, const char* location,

const char* detail) {

OOMDetails details;

details.detail = detail;

FatalProcessOutOfMemory(i_isolate, location, details);

}

void Utils::ReportApiFailure(const char* location, const char* message) {

i::Isolate* i_isolate = i::Isolate::TryGetCurrent();

FatalErrorCallback callback = nullptr;

if (i_isolate != nullptr) {

callback = i_isolate->exception_behavior();

}

if (callback == nullptr) {

base::OS::PrintError("\n#\n# Fatal error in %s\n# %s\n#\n\n", location,

message);

base::OS::Abort();

} else {

callback(location, message);

}

i_isolate->SignalFatalError();

}

void Utils::ReportOOMFailure(i::Isolate* i_isolate, const char* location,

const OOMDetails& details) {

if (auto oom_callback = i_isolate->oom_behavior()) {

oom_callback(location, details);

} else {

// TODO(wfh): Remove this fallback once Blink is setting OOM handler. See

// crbug.com/614440.

FatalErrorCallback fatal_callback = i_isolate->exception_behavior();

if (fatal_callback == nullptr) {

base::OS::PrintError("\n#\n# Fatal %s OOM in %s\n#\n\n",

details.is_heap_oom ? "javascript" : "process",

location);

#ifdef V8_FUZZILLI

// Ignore OOM crashes for fuzzing but exit with an error such that

// samples are discarded by Fuzzilli.

exit(1);

#else

base::OS::Abort();

#endif // V8_FUZZILLI

} else {

fatal_callback(location,

details.is_heap_oom

? "Allocation failed - JavaScript heap out of memory"

: "Allocation failed - process out of memory");

}

}

i_isolate->SignalFatalError();

}

void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {

i::V8::SetSnapshotBlob(snapshot_blob);

}

namespace {

#ifdef V8_ENABLE_SANDBOX

// ArrayBufferAllocator to use when the sandbox is enabled in which case all

// ArrayBuffer backing stores need to be allocated inside the sandbox.

class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {

public:

void* Allocate(size_t length) override {

return allocator_->Allocate(length);

}

void* AllocateUninitialized(size_t length) override {

return Allocate(length);

}

void Free(void* data, size_t length) override {

return allocator_->Free(data);

}

private:

// Backend allocator shared by all ArrayBufferAllocator instances. This way,

// there is a single region of virtual addres space reserved inside the

// sandbox from which all ArrayBufferAllocators allocate their memory,

// instead of each allocator creating their own region, which may cause

// address space exhaustion inside the sandbox.

// TODO(chromium:1340224): replace this with a more efficient allocator.

class BackendAllocator {

public:

BackendAllocator() {

CHECK(i::GetProcessWideSandbox()->is_initialized());

VirtualAddressSpace* vas = i::GetProcessWideSandbox()->address_space();

constexpr size_t max_backing_memory_size = 8ULL * i::GB;

constexpr size_t min_backing_memory_size = 1ULL * i::GB;

size_t backing_memory_size = max_backing_memory_size;

i::Address backing_memory_base = 0;

while (!backing_memory_base &&

backing_memory_size >= min_backing_memory_size) {

backing_memory_base = vas->AllocatePages(

VirtualAddressSpace::kNoHint, backing_memory_size, kChunkSize,

PagePermissions::kNoAccess);

if (!backing_memory_base) {

backing_memory_size /= 2;

}

}

if (!backing_memory_base) {

i::V8::FatalProcessOutOfMemory(

nullptr,

"Could not reserve backing memory for ArrayBufferAllocators");

}

DCHECK(IsAligned(backing_memory_base, kChunkSize));

region_alloc_ = std::make_unique<base::RegionAllocator>(

backing_memory_base, backing_memory_size, kAllocationGranularity);

end_of_accessible_region_ = region_alloc_->begin();

// Install a on-merge callback to discard or decommit unused pages.

region_alloc_->set_on_merge_callback([this](i::Address start,

size_t size) {

mutex_.AssertHeld();

VirtualAddressSpace* vas = i::GetProcessWideSandbox()->address_space();

i::Address end = start + size;

if (end == region_alloc_->end() &&

start <= end_of_accessible_region_ - kChunkSize) {

// Can shrink the accessible region.

i::Address new_end_of_accessible_region = RoundUp(start, kChunkSize);

size_t size =

end_of_accessible_region_ - new_end_of_accessible_region;

CHECK(vas->DecommitPages(new_end_of_accessible_region, size));

end_of_accessible_region_ = new_end_of_accessible_region;

} else if (size >= 2 * kChunkSize) {

// Can discard pages. The pages stay accessible, so the size of the

// accessible region doesn't change.

i::Address chunk_start = RoundUp(start, kChunkSize);

i::Address chunk_end = RoundDown(start + size, kChunkSize);

CHECK(vas->DiscardSystemPages(chunk_start, chunk_end - chunk_start));

}

});

}

~BackendAllocator() {

// The sandbox may already have been torn down, in which case there's no

// need to free any memory.

if (i::GetProcessWideSandbox()->is_initialized()) {

VirtualAddressSpace* vas = i::GetProcessWideSandbox()->address_space();

vas->FreePages(region_alloc_->begin(), region_alloc_->size());

}

}

BackendAllocator(const BackendAllocator&) = delete;

BackendAllocator& operator=(const BackendAllocator&) = delete;

void* Allocate(size_t length) {

base::MutexGuard guard(&mutex_);

length = RoundUp(length, kAllocationGranularity);

i::Address region = region_alloc_->AllocateRegion(length);

if (region == base::RegionAllocator::kAllocationFailure) return nullptr;

// Check if the memory is inside the accessible region. If not, grow it.

i::Address end = region + length;

size_t length_to_memset = length;

if (end > end_of_accessible_region_) {

VirtualAddressSpace* vas = i::GetProcessWideSandbox()->address_space();

i::Address new_end_of_accessible_region = RoundUp(end, kChunkSize);

size_t size = new_end_of_accessible_region - end_of_accessible_region_;

if (!vas->SetPagePermissions(end_of_accessible_region_, size,

PagePermissions::kReadWrite)) {

CHECK(region_alloc_->FreeRegion(region));

return nullptr;

}

// The pages that were inaccessible are guaranteed to be zeroed, so only

// memset until the previous end of the accessible region.

length_to_memset = end_of_accessible_region_ - region;

end_of_accessible_region_ = new_end_of_accessible_region;

}

void* mem = reinterpret_cast<void*>(region);

memset(mem, 0, length_to_memset);

return mem;

}

void Free(void* data) {

base::MutexGuard guard(&mutex_);

region_alloc_->FreeRegion(reinterpret_cast<i::Address>(data));

}

static BackendAllocator* SharedInstance() {

static base::LeakyObject<BackendAllocator> instance;

return instance.get();

}

private:

// Use a region allocator with a "page size" of 128 bytes as a reasonable

// compromise between the number of regions it has to manage and the amount

// of memory wasted due to rounding allocation sizes up to the page size.

static constexpr size_t kAllocationGranularity = 128;

// The backing memory's accessible region is grown in chunks of this size.

static constexpr size_t kChunkSize = 1 * i::MB;

std::unique_ptr<base::RegionAllocator> region_alloc_;

size_t end_of_accessible_region_;

base::Mutex mutex_;

};

BackendAllocator* allocator_ = BackendAllocator::SharedInstance();

};

#else

class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {

public:

void* Allocate(size_t length) override { return base::Calloc(length, 1); }

void* AllocateUninitialized(size_t length) override {

return base::Malloc(length);

}

void Free(void* data, size_t) override { base::Free(data); }

void* Reallocate(void* data, size_t old_length, size_t new_length) override {

void* new_data = base::Realloc(data, new_length);

if (new_length > old_length) {

memset(reinterpret_cast<uint8_t*>(new_data) + old_length, 0,

new_length - old_length);

}

return new_data;

}

};

#endif // V8_ENABLE_SANDBOX

struct SnapshotCreatorData {

explicit SnapshotCreatorData(Isolate* v8_isolate) : isolate_(v8_isolate) {}

static SnapshotCreatorData* cast(void* data) {

return reinterpret_cast<SnapshotCreatorData*>(data);

}

ArrayBufferAllocator allocator_;

Isolate* isolate_;

Persistent<Context> default_context_;

SerializeInternalFieldsCallback default_embedder_fields_serializer_;

std::vector<Global<Context>> contexts_;

std::vector<SerializeInternalFieldsCallback> embedder_fields_serializers_;

bool created_ = false;

};

} // namespace

SnapshotCreator::SnapshotCreator(Isolate* v8_isolate,

const intptr_t* external_references,

const StartupData* existing_snapshot) {

SnapshotCreatorData* data = new SnapshotCreatorData(v8_isolate);

i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);

i_isolate->set_array_buffer_allocator(&data->allocator_);

i_isolate->set_api_external_references(external_references);

i_isolate->enable_serializer();

v8_isolate->Enter();

const StartupData* blob = existing_snapshot

? existing_snapshot

: i::Snapshot::DefaultSnapshotBlob();

if (blob && blob->raw_size > 0) {

i_isolate->set_snapshot_blob(blob);

i::Snapshot::Initialize(i_isolate);

} else {

i_isolate->InitWithoutSnapshot();

}

data_ = data;

// Disable batch compilation during snapshot creation.

i_isolate->baseline_batch_compiler()->set_enabled(false);

}

SnapshotCreator::SnapshotCreator(const intptr_t* external_references,

const StartupData* existing_snapshot)

: SnapshotCreator(Isolate::Allocate(), external_references,

existing_snapshot) {}

SnapshotCreator::~SnapshotCreator() {

SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);

Isolate* v8_isolate = data->isolate_;

v8_isolate->Exit();

v8_isolate->Dispose();

delete data;

}

Isolate* SnapshotCreator::GetIsolate() {

return SnapshotCreatorData::cast(data_)->isolate_;

}

void SnapshotCreator::SetDefaultContext(

Local<Context> context, SerializeInternalFieldsCallback callback) {

DCHECK(!context.IsEmpty());

SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);

DCHECK(!data->created_);

DCHECK(data->default_context_.IsEmpty());

Isolate* v8_isolate = data->isolate_;

CHECK_EQ(v8_isolate, context->GetIsolate());

data->default_context_.Reset(v8_isolate, context);

data->default_embedder_fields_serializer_ = callback;

}

size_t SnapshotCreator::AddContext(Local<Context> context,

SerializeInternalFieldsCallback callback) {

DCHECK(!context.IsEmpty());

SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);

DCHECK(!data->created_);

Isolate* v8_isolate = data->isolate_;

CHECK_EQ(v8_isolate, context->GetIsolate());

size_t index = data->contexts_.size();

data->contexts_.emplace_back(v8_isolate, context);

data->embedder_fields_serializers_.push_back(callback);

return index;

}

size_t SnapshotCreator::AddData(i::Address object) {

DCHECK_NE(object, i::kNullAddress);

SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);

DCHECK(!data->created_);

i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(data->isolate_);

i::HandleScope scope(i_isolate);

i::Handle<i::Object> obj(i::Object(object), i_isolate);

i::Handle<i::ArrayList> list;

if (!i_isolate->heap()->serialized_objects().IsArrayList()) {

list = i::ArrayList::New(i_isolate, 1);

} else {

list = i::Handle<i::ArrayList>(

i::ArrayList::cast(i_isolate->heap()->serialized_objects()), i_isolate);

}

size_t index = static_cast<size_t>(list->Length());

list = i::ArrayList::Add(i_isolate, list, obj);

i_isolate->heap()->SetSerializedObjects(*list);

return index;

}

size_t SnapshotCreator::AddData(Local<Context> context, i::Address object) {

DCHECK_NE(object, i::kNullAddress);

DCHECK(!SnapshotCreatorData::cast(data_)->created_);

i::Handle<i::Context> ctx = Utils::OpenHandle(*context);

i::Isolate* i_isolate = ctx->GetIsolate();

i::HandleScope scope(i_isolate);

i::Handle<i::Object> obj(i::Object(object), i_isolate);

i::Handle<i::ArrayList> list;

if (!ctx->serialized_objects().IsArrayList()) {

list = i::ArrayList::New(i_isolate, 1);

} else {

list = i::Handle<i::ArrayList>(

i::ArrayList::cast(ctx->serialized_objects()), i_isolate);

}

size_t index = static_cast<size_t>(list->Length());

list = i::ArrayList::Add(i_isolate, list, obj);

ctx->set_serialized_objects(*list);

return index;

}

namespace {

void ConvertSerializedObjectsToFixedArray(Local<Context> context) {

i::Handle<i::Context> ctx = Utils::OpenHandle(*context);

i::Isolate* i_isolate = ctx->GetIsolate();

if (!ctx->serialized_objects().IsArrayList()) {

ctx->set_serialized_objects(

i::ReadOnlyRoots(i_isolate).empty_fixed_array());

} else {

i::Handle<i::ArrayList> list(i::ArrayList::cast(ctx->serialized_objects()),

i_isolate);

i::Handle<i::FixedArray> elements = i::ArrayList::Elements(i_isolate, list);

ctx->set_serialized_objects(*elements);

}

}

void ConvertSerializedObjectsToFixedArray(i::Isolate* i_isolate) {

if (!i_isolate->heap()->serialized_objects().IsArrayList()) {

i_isolate->heap()->SetSerializedObjects(

i::ReadOnlyRoots(i_isolate).empty_fixed_array());

} else {

i::Handle<i::ArrayList> list(

i::ArrayList::cast(i_isolate->heap()->serialized_objects()), i_isolate);

i::Handle<i::FixedArray> elements = i::ArrayList::Elements(i_isolate, list);

i_isolate->heap()->SetSerializedObjects(*elements);

}

}

} // anonymous namespace

StartupData SnapshotCreator::CreateBlob(

SnapshotCreator::FunctionCodeHandling function_code_handling) {

SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);

Isolate* isolate = data->isolate_;

i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);

Utils::ApiCheck(!data->created_, "v8::SnapshotCreator::CreateBlob",

"CreateBlob() cannot be called more than once on the same "

"SnapshotCreator");

Utils::ApiCheck(

!data->default_context_.IsEmpty(), "v8::SnapshotCreator::CreateBlob",

"CreateBlob() cannot be called before the default context is set");

const int num_additional_contexts = static_cast<int>(data->contexts_.size());

const int num_contexts = num_additional_contexts + 1; // The default context.

// Create and store lists of embedder-provided data needed during

// serialization.

{

i::HandleScope scope(i_isolate);

// Convert list of context-independent data to FixedArray.

ConvertSerializedObjectsToFixedArray(i_isolate);

// Convert lists of context-dependent data to FixedArray.

ConvertSerializedObjectsToFixedArray(

data->default_context_.Get(data->isolate_));

for (int i = 0; i < num_additional_contexts; i++) {

ConvertSerializedObjectsToFixedArray(data->contexts_[i].Get(isolate));

}

// We need to store the global proxy size upfront in case we need the

// bootstrapper to create a global proxy before we deserialize the context.

i::Handle<i::FixedArray> global_proxy_sizes =

i_isolate->factory()->NewFixedArray(num_additional_contexts,

i::AllocationType::kOld);

for (int i = 0; i < num_additional_contexts; i++) {

i::Handle<i::Context> context =

v8::Utils::OpenHandle(*data->contexts_[i].Get(isolate));

global_proxy_sizes->set(i,

i::Smi::FromInt(context->global_proxy().Size()));

}

i_isolate->heap()->SetSerializedGlobalProxySizes(*global_proxy_sizes);

}

// We might rehash strings and re-sort descriptors. Clear the lookup cache.

i_isolate->descriptor_lookup_cache()->Clear();

// If we don't do this then we end up with a stray root pointing at the

// context even after we have disposed of the context.

i_isolate->heap()->CollectAllAvailableGarbage(

i::GarbageCollectionReason::kSnapshotCreator);

{

i::HandleScope scope(i_isolate);

i_isolate->heap()->CompactWeakArrayLists();

}

i::Snapshot::ClearReconstructableDataForSerialization(

i_isolate, function_code_handling == FunctionCodeHandling::kClear);

i::SafepointKind safepoint_kind = i_isolate->has_shared_heap()

? i::SafepointKind::kGlobal

: i::SafepointKind::kIsolate;

i::SafepointScope safepoint_scope(i_isolate, safepoint_kind);

i::DisallowGarbageCollection no_gc_from_here_on;

// Create a vector with all contexts and clear associated Persistent fields.

// Note these contexts may be dead after calling Clear(), but will not be

// collected until serialization completes and the DisallowGarbageCollection

// scope above goes out of scope.

std::vector<i::Context> contexts;

contexts.reserve(num_contexts);

{

i::HandleScope scope(i_isolate);

contexts.push_back(

*v8::Utils::OpenHandle(*data->default_context_.Get(data->isolate_)));

data->default_context_.Reset();

for (int i = 0; i < num_additional_contexts; i++) {

i::Handle<i::Context> context =

v8::Utils::OpenHandle(*data->contexts_[i].Get(isolate));

contexts.push_back(*context);

}

data->contexts_.clear();

}

// Check that values referenced by global/eternal handles are accounted for.

i::SerializedHandleChecker handle_checker(i_isolate, &contexts);

CHECK(handle_checker.CheckGlobalAndEternalHandles());

// Create a vector with all embedder fields serializers.

std::vector<SerializeInternalFieldsCallback> embedder_fields_serializers;

embedder_fields_serializers.reserve(num_contexts);

embedder_fields_serializers.push_back(

data->default_embedder_fields_serializer_);

for (int i = 0; i < num_additional_contexts; i++) {

embedder_fields_serializers.push_back(

data->embedder_fields_serializers_[i]);

}

data->created_ = true;

return i::Snapshot::Create(i_isolate, &contexts, embedder_fields_serializers,

safepoint_scope, no_gc_from_here_on);

}

bool StartupData::CanBeRehashed() const {

DCHECK(i::Snapshot::VerifyChecksum(this));

return i::Snapshot::ExtractRehashability(this);

}

bool StartupData::IsValid() const { return i::Snapshot::VersionIsValid(this); }

void V8::SetDcheckErrorHandler(DcheckErrorCallback that) {

v8::base::SetDcheckFunction(that);

}

void V8::SetFlagsFromString(const char* str) {

SetFlagsFromString(str, strlen(str));

}

void V8::SetFlagsFromString(const char* str, size_t length) {

i::FlagList::SetFlagsFromString(str, length);

i::FlagList::EnforceFlagImplications();

}

void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {

using HelpOptions = i::FlagList::HelpOptions;

i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags,

HelpOptions(HelpOptions::kDontExit));

}

RegisteredExtension* RegisteredExtension::first_extension_ = nullptr;

RegisteredExtension::RegisteredExtension(std::unique_ptr<Extension> extension)

: extension_(std::move(extension)) {}

// static

void RegisteredExtension::Register(std::unique_ptr<Extension> extension) {

RegisteredExtension* new_extension =

new RegisteredExtension(std::move(extension));

new_extension->next_ = first_extension_;

first_extension_ = new_extension;

}

// static

void RegisteredExtension::UnregisterAll() {

RegisteredExtension* re = first_extension_;

while (re != nullptr) {

RegisteredExtension* next = re->next();

delete re;

re = next;

}

first_extension_ = nullptr;

}

namespace {

class ExtensionResource : public String::ExternalOneByteStringResource {

public:

ExtensionResource() : data_(nullptr), length_(0) {}

ExtensionResource(const char* data, size_t length)

: data_(data), length_(length) {}

const char* data() const override { return data_; }

size_t length() const override { return length_; }

void Dispose() override {}

private:

const char* data_;

size_t length_;

};

} // anonymous namespace

void RegisterExtension(std::unique_ptr<Extension> extension) {

RegisteredExtension::Register(std::move(extension));

}

Extension::Extension(const char* name, const char* source, int dep_count,

const char** deps, int source_length)

: name_(name),

source_length_(source_length >= 0

? source_length

: (source ? static_cast<int>(strlen(source)) : 0)),

dep_count_(dep_count),

deps_(deps),

auto_enable_(false) {

source_ = new ExtensionResource(source, source_length_);

CHECK(source != nullptr || source_length_ == 0);

}

void ResourceConstraints::ConfigureDefaultsFromHeapSize(

size_t initial_heap_size_in_bytes, size_t maximum_heap_size_in_bytes) {

CHECK_LE(initial_heap_size_in_bytes, maximum_heap_size_in_bytes);

if (maximum_heap_size_in_bytes == 0) {

return;

}

size_t young_generation, old_generation;

i::Heap::GenerationSizesFromHeapSize(maximum_heap_size_in_bytes,

&young_generation, &old_generation);

set_max_young_generation_size_in_bytes(

std::max(young_generation, i::Heap::MinYoungGenerationSize()));

set_max_old_generation_size_in_bytes(

std::max(old_generation, i::Heap::MinOldGenerationSize()));

if (initial_heap_size_in_bytes > 0) {

i::Heap::GenerationSizesFromHeapSize(initial_heap_size_in_bytes,

&young_generation, &old_generation);

// We do not set lower bounds for the initial sizes.

set_initial_young_generation_size_in_bytes(young_generation);

set_initial_old_generation_size_in_bytes(old_generation);

}

if (i::kPlatformRequiresCodeRange) {

set_code_range_size_in_bytes(

std::min(i::kMaximalCodeRangeSize, maximum_heap_size_in_bytes));

}

}

void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,

uint64_t virtual_memory_limit) {

size_t heap_size = i::Heap::HeapSizeFromPhysicalMemory(physical_memory);

size_t young_generation, old_generation;

i::Heap::GenerationSizesFromHeapSize(heap_size, &young_generation,

&old_generation);

set_max_young_generation_size_in_bytes(young_generation);

set_max_old_generation_size_in_bytes(old_generation);

if (virtual_memory_limit > 0 && i::kPlatformRequiresCodeRange) {

set_code_range_size_in_bytes(

std::min(i::kMaximalCodeRangeSize,

static_cast<size_t>(virtual_memory_limit / 8)));

}

}

namespace internal {

i::Address* GlobalizeTracedReference(i::Isolate* i_isolate, i::Address* obj,

internal::Address* slot,

GlobalHandleStoreMode store_mode) {

API_RCS_SCOPE(i_isolate, TracedGlobal, New);

#ifdef DEBUG

Utils::ApiCheck((slot != nullptr), "v8::GlobalizeTracedReference",

"the address slot must be not null");

#endif

auto result = i_isolate->traced_handles()->Create(*obj, slot, store_mode);

#ifdef VERIFY_HEAP

if (i::v8_flags.verify_heap) {

i::Object(*obj).ObjectVerify(i_isolate);

}

#endif // VERIFY_HEAP

return result.location();

}

void MoveTracedReference(internal::Address** from, internal::Address** to) {

TracedHandles::Move(from, to);

}

void CopyTracedReference(const internal::Address* const* from,

internal::Address** to) {

TracedHandles::Copy(from, to);

}

void DisposeTracedReference(internal::Address* location) {

TracedHandles::Destroy(location);

}

} // namespace internal

namespace api_internal {

i::Address* GlobalizeReference(i::Isolate* i_isolate, i::Address* obj) {

API_RCS_SCOPE(i_isolate, Persistent, New);

i::Handle<i::Object> result = i_isolate->global_handles()->Create(*obj);

#ifdef VERIFY_HEAP

if (i::v8_flags.verify_heap) {

i::Object(*obj).ObjectVerify(i_isolate);

}

#endif // VERIFY_HEAP

return result.location();

}

i::Address* CopyGlobalReference(i::Address* from) {

i::Handle<i::Object> result = i::GlobalHandles::CopyGlobal(from);

return result.location();

}

void MoveGlobalReference(internal::Address** from, internal::Address** to) {

i::GlobalHandles::MoveGlobal(from, to);

}

void MakeWeak(i::Address* location, void* parameter,

WeakCallbackInfo<void>::Callback weak_callback,

WeakCallbackType type) {

i::GlobalHandles::MakeWeak(location, parameter, weak_callback, type);

}

void MakeWeak(i::Address** location_addr) {

i::GlobalHandles::MakeWeak(location_addr);

}

void* ClearWeak(i::Address* location) {

return i::GlobalHandles::ClearWeakness(location);

}

void AnnotateStrongRetainer(i::Address* location, const char* label) {

i::GlobalHandles::AnnotateStrongRetainer(location, label);

}

void DisposeGlobal(i::Address* location) {

i::GlobalHandles::Destroy(location);

}

Value* Eternalize(Isolate* v8_isolate, Value* value) {

i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);

i::Object object = *Utils::OpenHandle(value);

int index = -1;

i_isolate->eternal_handles()->Create(i_isolate, object, &index);

return reinterpret_cast<Value*>(

i_isolate->eternal_handles()->Get(index).location());

}

void FromJustIsNothing() {

Utils::ApiCheck(false, "v8::FromJust", "Maybe value is Nothing");

}

void ToLocalEmpty() {

Utils::ApiCheck(false, "v8::ToLocalChecked", "Empty MaybeLocal");

}