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

#include <string.h> // For memcpy, strlen.

#ifdef V8_USE_ADDRESS_SANITIZER

#include <sanitizer/asan_interface.h>

#endif // V8_USE_ADDRESS_SANITIZER

#include <cmath> // For isnan.

#include <limits>

#include <vector>

#include "include/v8-debug.h"

#include "include/v8-profiler.h"

#include "include/v8-testing.h"

#include "include/v8-util.h"

#include "src/accessors.h"

#include "src/api-natives.h"

#include "src/assert-scope.h"

#include "src/background-parsing-task.h"

#include "src/base/functional.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/bootstrapper.h"

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

#include "src/code-stubs.h"

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

#include "src/compiler.h"

#include "src/contexts.h"

#include "src/conversions-inl.h"

#include "src/counters.h"

#include "src/debug/debug-coverage.h"

#include "src/debug/debug.h"

#include "src/deoptimizer.h"

#include "src/execution.h"

#include "src/frames-inl.h"

#include "src/gdb-jit.h"

#include "src/global-handles.h"

#include "src/globals.h"

#include "src/icu_util.h"

#include "src/isolate-inl.h"

#include "src/json-parser.h"

#include "src/json-stringifier.h"

#include "src/messages.h"

#include "src/objects-inl.h"

#include "src/parsing/parser.h"

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

#include "src/pending-compilation-error-handler.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/property-descriptor.h"

#include "src/property-details.h"

#include "src/property.h"

#include "src/prototype.h"

#include "src/runtime-profiler.h"

#include "src/runtime/runtime.h"

#include "src/simulator.h"

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

#include "src/snapshot/natives.h"

#include "src/snapshot/snapshot.h"

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

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

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

#include "src/unicode-inl.h"

#include "src/v8.h"

#include "src/v8threads.h"

#include "src/value-serializer.h"

#include "src/version.h"

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

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

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

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

namespace v8 {

#define LOG_API(isolate, class_name, function_name) \

i::RuntimeCallTimerScope _runtime_timer( \

isolate, &i::RuntimeCallStats::API_##class_name##_##function_name); \

LOG(isolate, ApiEntryCall("v8::" #class_name "::" #function_name))

#define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))

#define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, \

function_name, bailout_value, \

HandleScopeClass, do_callback) \

if (IsExecutionTerminatingCheck(isolate)) { \

return bailout_value; \

} \

HandleScopeClass handle_scope(isolate); \

CallDepthScope<do_callback> call_depth_scope(isolate, context); \

LOG_API(isolate, class_name, function_name); \

ENTER_V8(isolate); \

bool has_pending_exception = false

#define PREPARE_FOR_DEBUG_INTERFACE_EXECUTION_WITH_ISOLATE(isolate, T) \

if (IsExecutionTerminatingCheck(isolate)) { \

return MaybeLocal<T>(); \

} \

InternalEscapableScope handle_scope(isolate); \

CallDepthScope<false> call_depth_scope(isolate, v8::Local<v8::Context>()); \

ENTER_V8(isolate); \

bool has_pending_exception = false

#define PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \

bailout_value, HandleScopeClass, \

do_callback) \

auto isolate = context.IsEmpty() \

? i::Isolate::Current() \

: reinterpret_cast<i::Isolate*>(context->GetIsolate()); \

PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, do_callback);

#define PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE( \

category, name, context, class_name, function_name, bailout_value, \

HandleScopeClass, do_callback) \

auto isolate = context.IsEmpty() \

? i::Isolate::Current() \

: reinterpret_cast<i::Isolate*>(context->GetIsolate()); \

TRACE_EVENT_CALL_STATS_SCOPED(isolate, category, name); \

PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, do_callback);

#define PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, class_name, function_name, \

T) \

PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), class_name, \

function_name, MaybeLocal<T>(), \

InternalEscapableScope, false);

#define PREPARE_FOR_EXECUTION(context, class_name, function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \

MaybeLocal<T>(), InternalEscapableScope, \

false)

#define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, class_name, \

function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \

MaybeLocal<T>(), InternalEscapableScope, \

true)

#define PREPARE_FOR_EXECUTION_PRIMITIVE(context, class_name, function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \

Nothing<T>(), i::HandleScope, false)

#define PREPARE_FOR_EXECUTION_BOOL(context, class_name, function_name) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \

false, i::HandleScope, false)

#ifdef DEBUG

#define ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate) \

i::VMState<v8::OTHER> __state__((isolate)); \

i::DisallowJavascriptExecutionDebugOnly __no_script__((isolate)); \

i::DisallowExceptions __no_exceptions__((isolate))

#define ENTER_V8_FOR_NEW_CONTEXT(isolate) \

i::VMState<v8::OTHER> __state__((isolate)); \

i::DisallowExceptions __no_exceptions__((isolate))

#else

#define ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate) \

i::VMState<v8::OTHER> __state__((isolate));

#define ENTER_V8_FOR_NEW_CONTEXT(isolate) \

i::VMState<v8::OTHER> __state__((isolate));

#endif // DEBUG

#define EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, value) \

do { \

if (has_pending_exception) { \

call_depth_scope.Escape(); \

return value; \

} \

} while (false)

#define RETURN_ON_FAILED_EXECUTION(T) \

EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, MaybeLocal<T>())

#define RETURN_ON_FAILED_EXECUTION_PRIMITIVE(T) \

EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, Nothing<T>())

#define RETURN_ON_FAILED_EXECUTION_BOOL() \

EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, false)

#define RETURN_TO_LOCAL_UNCHECKED(maybe_local, T) \

return maybe_local.FromMaybe(Local<T>());

#define RETURN_ESCAPED(value) return handle_scope.Escape(value);

namespace {

Local<Context> ContextFromHeapObject(i::Handle<i::Object> obj) {

return reinterpret_cast<v8::Isolate*>(i::HeapObject::cast(*obj)->GetIsolate())

->GetCurrentContext();

}

class InternalEscapableScope : public v8::EscapableHandleScope {

public:

explicit inline InternalEscapableScope(i::Isolate* isolate)

: v8::EscapableHandleScope(reinterpret_cast<v8::Isolate*>(isolate)) {}

};

#ifdef DEBUG

void CheckMicrotasksScopesConsistency(i::Isolate* isolate) {

auto handle_scope_implementer = isolate->handle_scope_implementer();

if (handle_scope_implementer->microtasks_policy() ==

v8::MicrotasksPolicy::kScoped) {

DCHECK(handle_scope_implementer->GetMicrotasksScopeDepth() ||

!handle_scope_implementer->DebugMicrotasksScopeDepthIsZero());

}

}

#endif

template <bool do_callback>

class CallDepthScope {

public:

explicit CallDepthScope(i::Isolate* isolate, Local<Context> context)

: isolate_(isolate), context_(context), escaped_(false) {

// TODO(dcarney): remove this when blink stops crashing.

DCHECK(!isolate_->external_caught_exception());

isolate_->handle_scope_implementer()->IncrementCallDepth();

if (!context.IsEmpty()) {

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

i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();

if (isolate->context() != nullptr &&

isolate->context()->native_context() == env->native_context() &&

impl->LastEnteredContextWas(env)) {

context_ = Local<Context>();

} else {

context_->Enter();

}

}

if (do_callback) isolate_->FireBeforeCallEnteredCallback();

}

~CallDepthScope() {

if (!context_.IsEmpty()) context_->Exit();

if (!escaped_) isolate_->handle_scope_implementer()->DecrementCallDepth();

if (do_callback) isolate_->FireCallCompletedCallback();

#ifdef DEBUG

if (do_callback) CheckMicrotasksScopesConsistency(isolate_);

#endif

}

void Escape() {

DCHECK(!escaped_);

escaped_ = true;

auto handle_scope_implementer = isolate_->handle_scope_implementer();

handle_scope_implementer->DecrementCallDepth();

bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero();

isolate_->OptionalRescheduleException(call_depth_is_zero);

}

private:

i::Isolate* const isolate_;

Local<Context> context_;

bool escaped_;

bool do_callback_;

};

} // namespace

static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,

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

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

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

v8::Isolate* v8_isolate =

reinterpret_cast<v8::Isolate*>(script->GetIsolate());

ScriptOriginOptions options(script->origin_options());

v8::ScriptOrigin origin(

Utils::ToLocal(scriptName),

v8::Integer::New(v8_isolate, script->line_offset()),

v8::Integer::New(v8_isolate, script->column_offset()),

v8::Boolean::New(v8_isolate, options.IsSharedCrossOrigin()),

v8::Integer::New(v8_isolate, script->id()),

Utils::ToLocal(source_map_url),

v8::Boolean::New(v8_isolate, options.IsOpaque()),

v8::Boolean::New(v8_isolate, script->type() == i::Script::TYPE_WASM),

v8::Boolean::New(v8_isolate, options.IsModule()));

return origin;

}

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

void i::FatalProcessOutOfMemory(const char* location) {

i::V8::FatalProcessOutOfMemory(location, false);

}

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

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

void i::V8::FatalProcessOutOfMemory(const char* location, bool is_heap_oom) {

i::Isolate* isolate = i::Isolate::Current();

char last_few_messages[Heap::kTraceRingBufferSize + 1];

char js_stacktrace[Heap::kStacktraceBufferSize + 1];

i::HeapStats heap_stats;

if (isolate == nullptr) {

// On a background 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));

// Note that the embedder's oom handler won't be called in this case. We

// just crash.

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

return;

}

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 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 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 (isolate->heap()->HasBeenSetUp()) {

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

// HeapIterator here without doing a special GC.

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

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

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

first_newline = last_few_messages;

PrintF("\n<--- Last few GCs --->\n%s\n", first_newline);

PrintF("\n<--- JS stacktrace --->\n%s\n", js_stacktrace);

}

Utils::ReportOOMFailure(location, is_heap_oom);

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

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

}

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

i::Isolate* isolate = i::Isolate::Current();

FatalErrorCallback callback = 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);

}

isolate->SignalFatalError();

}

void Utils::ReportOOMFailure(const char* location, bool is_heap_oom) {

i::Isolate* isolate = i::Isolate::Current();

OOMErrorCallback oom_callback = isolate->oom_behavior();

if (oom_callback == nullptr) {

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

// crbug.com/614440.

FatalErrorCallback fatal_callback = isolate->exception_behavior();

if (fatal_callback == nullptr) {

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

is_heap_oom ? "javascript" : "process", location);

base::OS::Abort();

} else {

fatal_callback(location,

is_heap_oom

? "Allocation failed - JavaScript heap out of memory"

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

}

} else {

oom_callback(location, is_heap_oom);

}

isolate->SignalFatalError();

}

static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {

if (isolate->has_scheduled_exception()) {

return isolate->scheduled_exception() ==

isolate->heap()->termination_exception();

}

return false;

}

void V8::SetNativesDataBlob(StartupData* natives_blob) {

i::V8::SetNativesBlob(natives_blob);

}

void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {

i::V8::SetSnapshotBlob(snapshot_blob);

}

namespace {

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

public:

virtual void* Allocate(size_t length) {

void* data = AllocateUninitialized(length);

return data == NULL ? data : memset(data, 0, length);

}

virtual void* AllocateUninitialized(size_t length) { return malloc(length); }

virtual void Free(void* data, size_t) { free(data); }

};

bool RunExtraCode(Isolate* isolate, Local<Context> context,

const char* utf8_source, const char* name) {

base::ElapsedTimer timer;

timer.Start();

Context::Scope context_scope(context);

TryCatch try_catch(isolate);

Local<String> source_string;

if (!String::NewFromUtf8(isolate, utf8_source, NewStringType::kNormal)

.ToLocal(&source_string)) {

return false;

}

Local<String> resource_name =

String::NewFromUtf8(isolate, name, NewStringType::kNormal)

.ToLocalChecked();

ScriptOrigin origin(resource_name);

ScriptCompiler::Source source(source_string, origin);

Local<Script> script;

if (!ScriptCompiler::Compile(context, &source).ToLocal(&script)) return false;

if (script->Run(context).IsEmpty()) return false;

if (i::FLAG_profile_deserialization) {

i::PrintF("Executing custom snapshot script %s took %0.3f ms\n", name,

timer.Elapsed().InMillisecondsF());

}

timer.Stop();

CHECK(!try_catch.HasCaught());

return true;

}

struct SnapshotCreatorData {

explicit SnapshotCreatorData(Isolate* isolate)

: isolate_(isolate),

default_context_(),

contexts_(isolate),

templates_(isolate),

created_(false) {}

static SnapshotCreatorData* cast(void* data) {

return reinterpret_cast<SnapshotCreatorData*>(data);

}

ArrayBufferAllocator allocator_;

Isolate* isolate_;

Persistent<Context> default_context_;

PersistentValueVector<Context> contexts_;

PersistentValueVector<Template> templates_;

std::vector<SerializeInternalFieldsCallback> embedder_fields_serializers_;

bool created_;

};

} // namespace

SnapshotCreator::SnapshotCreator(intptr_t* external_references,

StartupData* existing_snapshot) {

i::Isolate* internal_isolate = new i::Isolate(true);

Isolate* isolate = reinterpret_cast<Isolate*>(internal_isolate);

SnapshotCreatorData* data = new SnapshotCreatorData(isolate);

data->isolate_ = isolate;

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

internal_isolate->set_api_external_references(external_references);

isolate->Enter();

const StartupData* blob = existing_snapshot

? existing_snapshot

: i::Snapshot::DefaultSnapshotBlob();

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

internal_isolate->set_snapshot_blob(blob);

i::Snapshot::Initialize(internal_isolate);

} else {

internal_isolate->Init(nullptr);

}

data_ = data;

}

SnapshotCreator::~SnapshotCreator() {

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

DCHECK(data->created_);

Isolate* isolate = data->isolate_;

isolate->Exit();

isolate->Dispose();

delete data;

}

Isolate* SnapshotCreator::GetIsolate() {

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

}

void SnapshotCreator::SetDefaultContext(Local<Context> context) {

DCHECK(!context.IsEmpty());

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

DCHECK(!data->created_);

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

Isolate* isolate = data->isolate_;

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

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

}

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

SerializeInternalFieldsCallback callback) {

DCHECK(!context.IsEmpty());

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

DCHECK(!data->created_);

Isolate* isolate = data->isolate_;

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

size_t index = static_cast<int>(data->contexts_.Size());

data->contexts_.Append(context);

data->embedder_fields_serializers_.push_back(callback);

return index;

}

size_t SnapshotCreator::AddTemplate(Local<Template> template_obj) {

DCHECK(!template_obj.IsEmpty());

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

DCHECK(!data->created_);

DCHECK_EQ(reinterpret_cast<i::Isolate*>(data->isolate_),

Utils::OpenHandle(*template_obj)->GetIsolate());

size_t index = static_cast<int>(data->templates_.Size());

data->templates_.Append(template_obj);

return index;

}

StartupData SnapshotCreator::CreateBlob(

SnapshotCreator::FunctionCodeHandling function_code_handling) {

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

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

DCHECK(!data->created_);

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

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

{

int num_templates = static_cast<int>(data->templates_.Size());

i::HandleScope scope(isolate);

i::Handle<i::FixedArray> templates =

isolate->factory()->NewFixedArray(num_templates, i::TENURED);

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

templates->set(i, *v8::Utils::OpenHandle(*data->templates_.Get(i)));

}

isolate->heap()->SetSerializedTemplates(*templates);

data->templates_.Clear();

// 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 =

isolate->factory()->NewFixedArray(num_additional_contexts, i::TENURED);

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

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

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

global_proxy_sizes->set(i,

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

}

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

}

// 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.

isolate->heap()->CollectAllAvailableGarbage(

i::GarbageCollectionReason::kSnapshotCreator);

isolate->heap()->CompactWeakFixedArrays();

i::DisallowHeapAllocation no_gc_from_here_on;

i::List<i::Object*> contexts(num_additional_contexts);

i::Object* default_context;

{

i::HandleScope scope(isolate);

default_context =

*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_.Get(i));

contexts.Add(*context);

}

data->contexts_.Clear();

}

// Complete in-object slack tracking for all functions.

i::HeapIterator heap_iterator(isolate->heap());

while (i::HeapObject* current_obj = heap_iterator.next()) {

if (!current_obj->IsJSFunction()) continue;

i::JSFunction* fun = i::JSFunction::cast(current_obj);

fun->CompleteInobjectSlackTrackingIfActive();

}

#ifdef DEBUG

i::ExternalReferenceTable::instance(isolate)->ResetCount();

#endif // DEBUG

i::StartupSerializer startup_serializer(isolate, function_code_handling);

startup_serializer.SerializeStrongReferences();

// Serialize each context with a new partial serializer.

i::List<i::SnapshotData*> context_snapshots(num_additional_contexts + 1);

{

// The default snapshot does not support embedder fields.

i::PartialSerializer partial_serializer(

isolate, &startup_serializer, v8::SerializeInternalFieldsCallback());

partial_serializer.Serialize(&default_context, false);

context_snapshots.Add(new i::SnapshotData(&partial_serializer));

}

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

i::PartialSerializer partial_serializer(

isolate, &startup_serializer, data->embedder_fields_serializers_[i]);

partial_serializer.Serialize(&contexts[i], true);

context_snapshots.Add(new i::SnapshotData(&partial_serializer));

}

startup_serializer.SerializeWeakReferencesAndDeferred();

#ifdef DEBUG

if (i::FLAG_external_reference_stats) {

i::ExternalReferenceTable::instance(isolate)->PrintCount();

}

#endif // DEBUG

i::SnapshotData startup_snapshot(&startup_serializer);

StartupData result =

i::Snapshot::CreateSnapshotBlob(&startup_snapshot, &context_snapshots);

// Delete heap-allocated context snapshot instances.

for (const auto& context_snapshot : context_snapshots) {

delete context_snapshot;

}

data->created_ = true;

return result;

}

StartupData V8::CreateSnapshotDataBlob(const char* embedded_source) {

// Create a new isolate and a new context from scratch, optionally run

// a script to embed, and serialize to create a snapshot blob.

StartupData result = {nullptr, 0};

base::ElapsedTimer timer;

timer.Start();

{

SnapshotCreator snapshot_creator;

Isolate* isolate = snapshot_creator.GetIsolate();

{

HandleScope scope(isolate);

Local<Context> context = Context::New(isolate);

if (embedded_source != NULL &&

!RunExtraCode(isolate, context, embedded_source, "<embedded>")) {

return result;

}

snapshot_creator.SetDefaultContext(context);

}

result = snapshot_creator.CreateBlob(

SnapshotCreator::FunctionCodeHandling::kClear);

}

if (i::FLAG_profile_deserialization) {

i::PrintF("Creating snapshot took %0.3f ms\n",

timer.Elapsed().InMillisecondsF());

}

timer.Stop();

return result;

}

StartupData V8::WarmUpSnapshotDataBlob(StartupData cold_snapshot_blob,

const char* warmup_source) {

CHECK(cold_snapshot_blob.raw_size > 0 && cold_snapshot_blob.data != NULL);

CHECK(warmup_source != NULL);

// Use following steps to create a warmed up snapshot blob from a cold one:

// - Create a new isolate from the cold snapshot.

// - Create a new context to run the warmup script. This will trigger

// compilation of executed functions.

// - Create a new context. This context will be unpolluted.

// - Serialize the isolate and the second context into a new snapshot blob.

StartupData result = {nullptr, 0};

base::ElapsedTimer timer;

timer.Start();

{

SnapshotCreator snapshot_creator(nullptr, &cold_snapshot_blob);

Isolate* isolate = snapshot_creator.GetIsolate();

{

HandleScope scope(isolate);

Local<Context> context = Context::New(isolate);

if (!RunExtraCode(isolate, context, warmup_source, "<warm-up>")) {

return result;

}

}

{

HandleScope handle_scope(isolate);

isolate->ContextDisposedNotification(false);

Local<Context> context = Context::New(isolate);

snapshot_creator.SetDefaultContext(context);

}

result = snapshot_creator.CreateBlob(

SnapshotCreator::FunctionCodeHandling::kKeep);

}

if (i::FLAG_profile_deserialization) {

i::PrintF("Warming up snapshot took %0.3f ms\n",

timer.Elapsed().InMillisecondsF());

}

timer.Stop();

return result;

}

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

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

i::FlagList::EnforceFlagImplications();

}

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

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

}

RegisteredExtension* RegisteredExtension::first_extension_ = NULL;

RegisteredExtension::RegisteredExtension(Extension* extension)

: extension_(extension) { }

void RegisteredExtension::Register(RegisteredExtension* that) {

that->next_ = first_extension_;

first_extension_ = that;

}

void RegisteredExtension::UnregisterAll() {

RegisteredExtension* re = first_extension_;

while (re != NULL) {

RegisteredExtension* next = re->next();

delete re;

re = next;

}

first_extension_ = NULL;

}

void RegisterExtension(Extension* that) {

RegisteredExtension* extension = new RegisteredExtension(that);

RegisteredExtension::Register(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)),

source_(source, source_length_),

dep_count_(dep_count),

deps_(deps),

auto_enable_(false) {

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

}

ResourceConstraints::ResourceConstraints()

: max_semi_space_size_(0),

max_old_space_size_(0),

max_executable_size_(0),

stack_limit_(NULL),

code_range_size_(0),

max_zone_pool_size_(0) {}

void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,

uint64_t virtual_memory_limit) {

#if V8_OS_ANDROID

// Android has higher physical memory requirements before raising the maximum

// heap size limits since it has no swap space.

const uint64_t low_limit = 512ul * i::MB;

const uint64_t medium_limit = 1ul * i::GB;

const uint64_t high_limit = 2ul * i::GB;

#else

const uint64_t low_limit = 512ul * i::MB;

const uint64_t medium_limit = 768ul * i::MB;

const uint64_t high_limit = 1ul * i::GB;

#endif

if (physical_memory <= low_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeLowMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeLowMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeLowMemoryDevice);

set_max_zone_pool_size(i::AccountingAllocator::kMaxPoolSizeLowMemoryDevice);

} else if (physical_memory <= medium_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeMediumMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeMediumMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeMediumMemoryDevice);

set_max_zone_pool_size(

i::AccountingAllocator::kMaxPoolSizeMediumMemoryDevice);

} else if (physical_memory <= high_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHighMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHighMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeHighMemoryDevice);

set_max_zone_pool_size(

i::AccountingAllocator::kMaxPoolSizeHighMemoryDevice);

} else {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHugeMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHugeMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeHugeMemoryDevice);

set_max_zone_pool_size(

i::AccountingAllocator::kMaxPoolSizeHugeMemoryDevice);

}

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

// Reserve no more than 1/8 of the memory for the code range, but at most

// kMaximalCodeRangeSize.

set_code_range_size(

i::Min(i::kMaximalCodeRangeSize / i::MB,

static_cast<size_t>((virtual_memory_limit >> 3) / i::MB)));

}

}

void SetResourceConstraints(i::Isolate* isolate,

const ResourceConstraints& constraints) {

int semi_space_size = constraints.max_semi_space_size();

int old_space_size = constraints.max_old_space_size();

int max_executable_size = constraints.max_executable_size();

size_t code_range_size = constraints.code_range_size();

size_t max_pool_size = constraints.max_zone_pool_size();

if (semi_space_size != 0 || old_space_size != 0 ||

max_executable_size != 0 || code_range_size != 0) {

isolate->heap()->ConfigureHeap(semi_space_size, old_space_size,

max_executable_size, code_range_size);

}

isolate->allocator()->ConfigureSegmentPool(max_pool_size);

if (constraints.stack_limit() != NULL) {

uintptr_t limit = reinterpret_cast<uintptr_t>(constraints.stack_limit());

isolate->stack_guard()->SetStackLimit(limit);

}

}

i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) {

LOG_API(isolate, Persistent, New);

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

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

(*obj)->ObjectVerify();

}

#endif // VERIFY_HEAP

return result.location();

}

i::Object** V8::CopyPersistent(i::Object** obj) {

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

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

(*obj)->ObjectVerify();

}

#endif // VERIFY_HEAP

return result.location();

}

void V8::RegisterExternallyReferencedObject(i::Object** object,

i::Isolate* isolate) {

isolate->heap()->RegisterExternallyReferencedObject(object);

}

void V8::MakeWeak(i::Object** location, void* parameter,

int embedder_field_index1, int embedder_field_index2,

WeakCallbackInfo<void>::Callback weak_callback) {

WeakCallbackType type = WeakCallbackType::kParameter;

if (embedder_field_index1 == 0) {

if (embedder_field_index2 == 1) {

type = WeakCallbackType::kInternalFields;

} else {

DCHECK_EQ(embedder_field_index2, -1);

type = WeakCallbackType::kInternalFields;

}

} else {

DCHECK_EQ(embedder_field_index1, -1);

DCHECK_EQ(embedder_field_index2, -1);

}

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

}

void V8::MakeWeak(i::Object** location, void* parameter,

WeakCallbackInfo<void>::Callback weak_callback,

WeakCallbackType type) {

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

}

void V8::MakeWeak(i::Object*** location_addr) {

i::GlobalHandles::MakeWeak(location_addr);

}

void* V8::ClearWeak(i::Object** location) {

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

}

void V8::DisposeGlobal(i::Object** location) {

i::GlobalHandles::Destroy(location);

}

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

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

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

int index = -1;

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

return reinterpret_cast<Value*>(

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

}

void V8::FromJustIsNothing() {

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

}

void V8::ToLocalEmpty() {

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

}

void V8::InternalFieldOutOfBounds(int index) {

Utils::ApiCheck(0 <= index && index < kInternalFieldsInWeakCallback,

"WeakCallbackInfo::GetInternalField",

"Internal field out of bounds.");

}

// --- H a n d l e s ---

HandleScope::HandleScope(Isolate* isolate) {

Initialize(isolate);

}

void HandleScope::Initialize(Isolate* isolate) {

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

// We do not want to check the correct usage of the Locker class all over the

// place, so we do it only here: Without a HandleScope, an embedder can do

// almost nothing, so it is enough to check in this central place.

// We make an exception if the serializer is enabled, which means that the

// Isolate is exclusively used to create a snapshot.

Utils::ApiCheck(

!v8::Locker::IsActive() ||

internal_isolate->thread_manager()->IsLockedByCurrentThread() ||

internal_isolate->serializer_enabled(),

"HandleScope::HandleScope",

"Entering the V8 API without proper locking in place");

i::HandleScopeData* current = internal_isolate->handle_scope_data();

isolate_ = internal_isolate;

prev_next_ = current->next;

prev_limit_ = current->limit;