Local<String>) {

Local<Value> wasm_code_gen =

context->GetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration);

return wasm_code_gen->IsUndefined() || wasm_code_gen->IsTrue();

DebugSealHandleScope scope(isolate);

Environment* env = Environment::GetCurrent(isolate);

return env != nullptr &&

(env->is_main_thread() || !env->is_stopping()) &&

env->abort_on_uncaught_exception() &&

env->should_abort_on_uncaught_toggle()[0] &&

!env->inside_should_not_abort_on_uncaught_scope();

Local<Value> exception,

Local<Array> trace) {

Environment* env = Environment::GetCurrent(context);

if (env == nullptr) {

return exception->ToString(context).FromMaybe(Local<Value>());

}

Realm* realm = Realm::GetCurrent(context);

Local<Function> prepare;

if (realm != nullptr) {

// If we are in a Realm, call the realm specific prepareStackTrace callback

// to avoid passing the JS objects (the exception and trace) across the

// realm boundary with the `Error.prepareStackTrace` override.

prepare = realm->prepare_stack_trace_callback();

} else {

// The context is created with ContextifyContext, call the principal

// realm's prepareStackTrace callback.

prepare = env->principal_realm()->prepare_stack_trace_callback();

}

if (prepare.IsEmpty()) {

return exception->ToString(context).FromMaybe(Local<Value>());

}

Local<Value> args[] = {

context->Global(),

exception,

trace,

};

// This TryCatch + Rethrow is required by V8 due to details around exception

// handling there. For C++ callbacks, V8 expects a scheduled exception (which

// is what ReThrow gives us). Just returning the empty MaybeLocal would leave

// us with a pending exception.

TryCatchScope try_catch(env);

MaybeLocal<Value> result =

prepare->Call(context, Undefined(env->isolate()), arraysize(args), args);

if (try_catch.HasCaught() && !try_catch.HasTerminated()) {

try_catch.ReThrow();

}

return result;

Mutex::ScopedLock lock(mutex_);

UnregisterPointerInternal(data, size);

NodeArrayBufferAllocator::Free(data, size);

Mutex::ScopedLock lock(mutex_);

NodeArrayBufferAllocator::RegisterPointer(data, size);

RegisterPointerInternal(data, size);

Mutex::ScopedLock lock(mutex_);

NodeArrayBufferAllocator::UnregisterPointer(data, size);

UnregisterPointerInternal(data, size);

size_t size) {

if (data == nullptr) return;

auto it = allocations_.find(data);

CHECK_NE(it, allocations_.end());

if (size > 0) {

// We allow allocations with size 1 for 0-length buffers to avoid having

// to deal with nullptr values.

CHECK_EQ(it->second, size);

}

allocations_.erase(it);

size_t size) {

if (data == nullptr) return;

CHECK_EQ(allocations_.count(data), 0);

allocations_[data] = size;

if (debug || per_process::cli_options->debug_arraybuffer_allocations)

return std::make_unique<DebuggingArrayBufferAllocator>();

else

return std::make_unique<NodeArrayBufferAllocator>();

const uint64_t constrained_memory = uv_get_constrained_memory();

const uint64_t total_memory = constrained_memory > 0 ?

std::min(uv_get_total_memory(), constrained_memory) :

uv_get_total_memory();

if (total_memory > 0 &&

params->constraints.max_old_generation_size_in_bytes() == 0) {

// V8 defaults to 700MB or 1.4GB on 32 and 64 bit platforms respectively.

// This default is based on browser use-cases. Tell V8 to configure the

// heap based on the actual physical memory.

params->constraints.ConfigureDefaults(total_memory, 0);

}

#ifdef NODE_ENABLE_VTUNE_PROFILING

params->code_event_handler = vTune::GetVtuneCodeEventHandler();

#endif

const IsolateSettings& s) {

if (s.flags & MESSAGE_LISTENER_WITH_ERROR_LEVEL)

isolate->AddMessageListenerWithErrorLevel(

errors::PerIsolateMessageListener,

Isolate::MessageErrorLevel::kMessageError |

Isolate::MessageErrorLevel::kMessageWarning);

auto* abort_callback = s.should_abort_on_uncaught_exception_callback ?

s.should_abort_on_uncaught_exception_callback :

ShouldAbortOnUncaughtException;

isolate->SetAbortOnUncaughtExceptionCallback(abort_callback);

auto* fatal_error_cb = s.fatal_error_callback ?

s.fatal_error_callback : OnFatalError;

isolate->SetFatalErrorHandler(fatal_error_cb);

auto* oom_error_cb =

s.oom_error_callback ? s.oom_error_callback : OOMErrorHandler;

isolate->SetOOMErrorHandler(oom_error_cb);

if ((s.flags & SHOULD_NOT_SET_PREPARE_STACK_TRACE_CALLBACK) == 0) {

auto* prepare_stack_trace_cb = s.prepare_stack_trace_callback ?

s.prepare_stack_trace_callback : PrepareStackTraceCallback;

isolate->SetPrepareStackTraceCallback(prepare_stack_trace_cb);

}

isolate->SetMicrotasksPolicy(s.policy);

auto* allow_wasm_codegen_cb = s.allow_wasm_code_generation_callback ?

s.allow_wasm_code_generation_callback : AllowWasmCodeGenerationCallback;

isolate->SetAllowWasmCodeGenerationCallback(allow_wasm_codegen_cb);

auto* modify_code_generation_from_strings_callback =

ModifyCodeGenerationFromStrings;

if (s.modify_code_generation_from_strings_callback != nullptr) {

modify_code_generation_from_strings_callback =

s.modify_code_generation_from_strings_callback;

}

isolate->SetModifyCodeGenerationFromStringsCallback(

modify_code_generation_from_strings_callback);

if ((s.flags & SHOULD_NOT_SET_WASM_STREAMING_CALLBACK) == 0) {

isolate->SetWasmStreamingCallback(wasm_web_api::StartStreamingCompilation);

}

Mutex::ScopedLock lock(node::per_process::cli_options_mutex);

if (per_process::cli_options->get_per_isolate_options()

->experimental_shadow_realm) {

isolate->SetHostCreateShadowRealmContextCallback(

shadow_realm::HostCreateShadowRealmContextCallback);

}

if ((s.flags & SHOULD_NOT_SET_PROMISE_REJECTION_CALLBACK) == 0) {

auto* promise_reject_cb = s.promise_reject_callback ?

s.promise_reject_callback : PromiseRejectCallback;

isolate->SetPromiseRejectCallback(promise_reject_cb);

}

if (s.flags & DETAILED_SOURCE_POSITIONS_FOR_PROFILING)

v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);

const IsolateSettings& settings) {

Isolate::Scope isolate_scope(isolate);

SetIsolateErrorHandlers(isolate, settings);

SetIsolateMiscHandlers(isolate, settings);

// When pointer compression is disabled, we cannot create new groups,

// in which case we'll always return the default.

if (IsolateGroup::CanCreateNewGroups()) {

return IsolateGroup::Create();

}

return IsolateGroup::GetDefault();

Mutex::ScopedLock lock(first_snapshot_mutex);

if (!first_snapshot_recorded) {

first_snapshot_recorded = true;

if (params->snapshot_blob != nullptr) {

first_snapshot_blob = *params->snapshot_blob;

}

first_external_references = params->external_references;

}

params->snapshot_blob =

first_snapshot_blob.data != nullptr ? &first_snapshot_blob : nullptr;

params->external_references = first_external_references;

std::unique_ptr<inspector::ParentInspectorHandle> impl;

explicit InspectorParentHandleImpl(

std::unique_ptr<inspector::ParentInspectorHandle>&& impl)

: impl(std::move(impl)) {}

Isolate* isolate = env->isolate();

Isolate::DisallowJavascriptExecutionScope disallow_js(isolate,

Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);

// A termination requested by Stop() targets this Environment; if no JS ran

// since, it is still pending and must not hit the isolate's next user.

isolate->CancelTerminateExecution();

{

HandleScope handle_scope(isolate); // For env->context().

Context::Scope context_scope(env->context());

SealHandleScope seal_handle_scope(isolate);

// Set the flag in accordance with the DisallowJavascriptExecutionScope

// above.

env->set_can_call_into_js(false);

env->set_stopping(true);

env->stop_sub_worker_contexts();

env->RunCleanup();

RunAtExit(env);

}

delete env;

StartExecutionCallbackWithModule cb,

EmbedderPreloadCallback preload) {

env->InitializeLibuv();

env->InitializeDiagnostics();

if (preload) {

env->set_embedder_preload(std::move(preload));

}

env->InitializeCompileCache();

return StartExecution(env, cb);

StartExecutionCallback cb,

EmbedderPreloadCallback preload) {

if (!cb) {

return LoadEnvironment(

env, StartExecutionCallbackWithModule{}, std::move(preload));

}

return LoadEnvironment(

env,

[cb = std::move(cb)](const StartExecutionCallbackInfoWithModule& info)

-> MaybeLocal<Value> {

StartExecutionCallbackInfo legacy_info{

info.process_object(), info.native_require(), info.run_module()};

return cb(legacy_info);

},

std::move(preload));

std::string_view main_script_source_utf8,

EmbedderPreloadCallback preload) {

ModuleData data;

data.set_source(main_script_source_utf8);

data.set_format(ModuleFormat::kCommonJS);

data.set_resource_name(env->exec_path());

return LoadEnvironment(env, &data, std::move(preload));

const ModuleData* data,

EmbedderPreloadCallback preload) {

// It could be empty when it's used by SEA to load an empty script.

CHECK_IMPLIES(data->source().size() > 0, data->source().data());

return LoadEnvironment(

env,

[data](const StartExecutionCallbackInfoWithModule& info)

-> MaybeLocal<Value> {

Environment* env = info.env();

Local<Context> context = env->context();

Isolate* isolate = env->isolate();

Local<Value> main_script =

ToV8Value(context, data->source()).ToLocalChecked();

Local<Value> format =

v8::Integer::New(isolate, static_cast<int>(data->format()));

Local<Value> resource_name =

ToV8Value(context, data->resource_name()).ToLocalChecked();

Local<Value> args[] = {main_script, format, resource_name};

return info.run_module()->Call(

context, Null(isolate), arraysize(args), args);

},

std::move(preload));

int thread_pool_size,

v8::TracingController* tracing_controller,

v8::PageAllocator* page_allocator) {

return std::make_unique<NodePlatform>(thread_pool_size,

tracing_controller,

page_allocator);

IsolateData* isolate_data) {

Isolate* isolate = Isolate::GetCurrent();

EscapableHandleScope handle_scope(isolate);

Local<Object> global = context->Global();

Local<Private> key = Private::ForApi(isolate,

FIXED_ONE_BYTE_STRING(isolate, "node:per_context_binding_exports"));

Local<Value> existing_value;

if (!global->GetPrivate(context, key).ToLocal(&existing_value))

return MaybeLocal<Object>();

if (existing_value->IsObject())

return handle_scope.Escape(existing_value.As<Object>());

// To initialize the per-context binding exports, a non-nullptr isolate_data

// is needed

CHECK(isolate_data);

Local<Object> exports = Object::New(isolate);

if (context->Global()->SetPrivate(context, key, exports).IsNothing() ||

InitializePrimordials(context, isolate_data).IsNothing()) {

return MaybeLocal<Object>();

}

return handle_scope.Escape(exports);

Local<ObjectTemplate> object_template) {

auto context = Context::New(isolate, nullptr, object_template);

if (context.IsEmpty()) return context;

if (InitializeContext(context).IsNothing()) {

return Local<Context>();

}

return context;

Isolate* isolate = Isolate::GetCurrent();

HandleScope handle_scope(isolate);

// When `IsCodeGenerationFromStringsAllowed` is true, V8 takes the fast path

// and ignores the ModifyCodeGenerationFromStrings callback. Set it to false

// to delegate the code generation validation to

// node::ModifyCodeGenerationFromStrings.

// The `IsCodeGenerationFromStringsAllowed` can be refreshed by V8 according

// to the runtime flags, propagate the value to the embedder data.

bool is_code_generation_from_strings_allowed =

context->IsCodeGenerationFromStringsAllowed();

context->AllowCodeGenerationFromStrings(false);

context->SetEmbedderData(

ContextEmbedderIndex::kAllowCodeGenerationFromStrings,

Boolean::New(isolate, is_code_generation_from_strings_allowed));

if (per_process::cli_options->disable_proto == "") {

return JustVoid();

}

// Remove __proto__

// https://github.com/nodejs/node/issues/31951

Local<Object> prototype;

{

Local<String> object_string =

FIXED_ONE_BYTE_STRING(isolate, "Object");

Local<String> prototype_string =

FIXED_ONE_BYTE_STRING(isolate, "prototype");

Local<Value> object_v;

if (!context->Global()

->Get(context, object_string)

.ToLocal(&object_v)) {

return Nothing<void>();

}

Local<Value> prototype_v;

if (!object_v.As<Object>()

->Get(context, prototype_string)

.ToLocal(&prototype_v)) {

return Nothing<void>();

}

prototype = prototype_v.As<Object>();

}

Local<String> proto_string =

FIXED_ONE_BYTE_STRING(isolate, "__proto__");

if (per_process::cli_options->disable_proto == "delete") {

if (prototype

->Delete(context, proto_string)

.IsNothing()) {

return Nothing<void>();

}

} else if (per_process::cli_options->disable_proto == "throw") {

Local<Value> thrower;

if (!Function::New(context, ProtoThrower)

.ToLocal(&thrower)) {

return Nothing<void>();

}

PropertyDescriptor descriptor(thrower, thrower);

descriptor.set_enumerable(false);

descriptor.set_configurable(true);

if (prototype

->DefineProperty(context, proto_string, descriptor)

.IsNothing()) {

return Nothing<void>();

}

} else if (per_process::cli_options->disable_proto != "") {

// Validated in ProcessGlobalArgs

UNREACHABLE("invalid --disable-proto mode");

}

return JustVoid();

Isolate* isolate = Isolate::GetCurrent();

HandleScope handle_scope(isolate);

// Delete `Intl.v8BreakIterator`

// https://github.com/nodejs/node/issues/14909

{

Context::Scope context_scope(context);

Local<String> intl_string = FIXED_ONE_BYTE_STRING(isolate, "Intl");

Local<String> break_iter_string =

FIXED_ONE_BYTE_STRING(isolate, "v8BreakIterator");

Local<Value> intl_v;

if (!context->Global()->Get(context, intl_string).ToLocal(&intl_v)) {

return Nothing<void>();

}

if (intl_v->IsObject() &&

intl_v.As<Object>()->Delete(context, break_iter_string).IsNothing()) {

return Nothing<void>();

}

}

return JustVoid();

Isolate* isolate = Isolate::GetCurrent();

HandleScope handle_scope(isolate);

// Initialize the default values.

context->SetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration,

True(isolate));

context->SetEmbedderData(

ContextEmbedderIndex::kAllowCodeGenerationFromStrings, True(isolate));

if (InitializeBaseContextForSnapshot(context).IsNothing()) {

return Nothing<void>();

}

return JustVoid();

IsolateData* isolate_data) {

CHECK(isolate_data);

Isolate* isolate = Isolate::GetCurrent();

EscapableHandleScope scope(isolate);

Context::Scope context_scope(context);

Local<ObjectTemplate> private_symbols = ObjectTemplate::New(isolate);

#define V(PropertyName, _) \

private_symbols->Set(isolate, #PropertyName, isolate_data->PropertyName());

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)

#undef V

Local<Object> private_symbols_object;

if (!private_symbols->NewInstance(context).ToLocal(&private_symbols_object) ||

private_symbols_object->SetPrototypeV2(context, Null(isolate))

.IsNothing()) {

return MaybeLocal<Object>();

}

return scope.Escape(private_symbols_object);

IsolateData* isolate_data) {

CHECK(isolate_data);

Isolate* isolate = Isolate::GetCurrent();

EscapableHandleScope scope(isolate);

Context::Scope context_scope(context);

Local<ObjectTemplate> per_isolate_symbols = ObjectTemplate::New(isolate);

#define V(PropertyName, _) \

per_isolate_symbols->Set( \

isolate, #PropertyName, isolate_data->PropertyName());

PER_ISOLATE_SYMBOL_PROPERTIES(V)

#undef V

Local<Object> per_isolate_symbols_object;

if (!per_isolate_symbols->NewInstance(context).ToLocal(

&per_isolate_symbols_object) ||

per_isolate_symbols_object->SetPrototypeV2(context, Null(isolate))

.IsNothing()) {