#include "src/api/api.h"

#include <algorithm> // For min

#include <cmath> // For isnan.

#include <limits>

#include <string>

#include <utility> // For move

#include <vector>

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

#include "include/v8-profiler.h"

#include "include/v8-util.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/platform.h"

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

#include "src/base/safe_conversions.h"

#include "src/base/utils/random-number-generator.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/common/assert-scope.h"

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

#include "src/common/globals.h"

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

#include "src/date/date.h"

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

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

#include "src/debug/debug-type-profile.h"

#include "src/debug/debug.h"

#include "src/debug/liveedit.h"

#include "src/deoptimizer/deoptimizer.h"

#include "src/diagnostics/gdb-jit.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/runtime-profiler.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/heap/embedder-tracing.h"

#include "src/heap/heap-inl.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.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/frame-array-inl.h"

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

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

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

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

#include "src/objects/js-generator-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/slots.h"

#include "src/objects/smi.h"

#include "src/objects/stack-frame-info-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/snapshot/code-serializer.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/trap-handler/trap-handler.h"

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

#include "src/utils/version.h"

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

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

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

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

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

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

#if V8_OS_LINUX || V8_OS_MACOSX || V8_OS_FREEBSD

#include <signal.h>

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

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

#endif

#if V8_OS_WIN

#include <versionhelpers.h>

#include <windows.h>

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

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

#if defined(V8_OS_WIN64)

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

#endif // V8_OS_WIN64

#endif // V8_OS_WIN

#define TRACE_BS(...) \

do { \

if (i::FLAG_trace_backing_store) PrintF(__VA_ARGS__); \

} while (false)

namespace v8 {

#define LOG_API(isolate, class_name, function_name) \

i::RuntimeCallTimerScope _runtime_timer( \

isolate, i::RuntimeCallCounterId::kAPI_##class_name##_##function_name); \

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

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

#define ENTER_V8_HELPER_DO_NOT_USE(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); \

i::VMState<v8::OTHER> __state__((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>()); \

i::VMState<v8::OTHER> __state__((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()); \

ENTER_V8_HELPER_DO_NOT_USE(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, do_callback);

#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 ENTER_V8(isolate, context, class_name, function_name, bailout_value, \

HandleScopeClass) \

ENTER_V8_HELPER_DO_NOT_USE(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, true)

#ifdef DEBUG

#define ENTER_V8_NO_SCRIPT(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass) \

ENTER_V8_HELPER_DO_NOT_USE(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, false); \

i::DisallowJavascriptExecutionDebugOnly __no_script__((isolate))

#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(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass) \

ENTER_V8_HELPER_DO_NOT_USE(isolate, context, class_name, function_name, \

bailout_value, HandleScopeClass, false)

#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_DO_NOT_USE(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_DO_NOT_USE(isolate, MaybeLocal<T>())

#define RETURN_ON_FAILED_EXECUTION_PRIMITIVE(T) \

EXCEPTION_BAILOUT_CHECK_SCOPED_DO_NOT_USE(isolate, Nothing<T>())

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

namespace {

class InternalEscapableScope : public v8::EscapableHandleScope {

};

#ifdef V8_CHECK_MICROTASKS_SCOPES_CONSISTENCY

void CheckMicrotasksScopesConsistency(i::MicrotaskQueue* microtask_queue) {

}

#endif

template <bool do_callback>

class CallDepthScope {

};

} // namespace

static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,

}

void i::FatalProcessOutOfMemory(i::Isolate* isolate, const char* location) {

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

}

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

bool is_heap_oom) {

char last_few_messages[Heap::kTraceRingBufferSize + 1];

char js_stacktrace[Heap::kStacktraceBufferSize + 1];

i::HeapStats heap_stats;

if (isolate == nullptr) {

isolate = Isolate::TryGetCurrent();

}

if (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));

// Note that the embedder's oom handler is also not available and therefore

// won't be called in this case. We just crash.

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

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

// HeapObjectIterator here without doing a special GC.

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

if (!FLAG_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(isolate, 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) {

}

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

}

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

}

void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {

i::V8::SetSnapshotBlob(snapshot_blob);

}

namespace {

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

};

struct SnapshotCreatorData {

};

} // namespace

SnapshotCreator::SnapshotCreator(Isolate* isolate,

}

SnapshotCreator::SnapshotCreator(const intptr_t* external_references,

StartupData* existing_snapshot)

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

existing_snapshot) {}

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(

}

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

}

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

}

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

}

namespace {

void ConvertSerializedObjectsToFixedArray(Local<Context> context) {

}

void ConvertSerializedObjectsToFixedArray(i::Isolate* isolate) {

}

} // anonymous namespace

StartupData SnapshotCreator::CreateBlob(

}

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) {

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

}

RegisteredExtension* RegisteredExtension::first_extension_ = nullptr;

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

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

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

}

void RegisteredExtension::UnregisterAll() {

}

namespace {

class ExtensionResource : public String::ExternalOneByteStringResource {

};

} // 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,

}

void ResourceConstraints::ConfigureDefaultsFromHeapSize(

}

void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,

}

size_t ResourceConstraints::max_semi_space_size_in_kb() const {

}

void ResourceConstraints::set_max_semi_space_size_in_kb(size_t limit_in_kb) {

set_max_young_generation_size_in_bytes(

i::Heap::YoungGenerationSizeFromSemiSpaceSize(limit_in_kb * i::KB));

}

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

LOG_API(isolate, Persistent, New);

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

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

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

}

#endif // VERIFY_HEAP

return result.location();

}

i::Address* V8::GlobalizeTracedReference(i::Isolate* isolate, i::Address* obj,

internal::Address* slot,

bool has_destructor) {

LOG_API(isolate, TracedGlobal, New);

#ifdef DEBUG

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

"the address slot must be not null");

#endif

i::Handle<i::Object> result =

isolate->global_handles()->CreateTraced(*obj, slot, has_destructor);

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

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

}

#endif // VERIFY_HEAP

return result.location();

}

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

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

return result.location();

}

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

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

}

void V8::MoveTracedGlobalReference(internal::Address** from,

internal::Address** to) {

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