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

}

Local<Function> prepare = env->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) {

// 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);

}

params->embedder_wrapper_object_index = BaseObject::InternalFields::kSlot;

params->embedder_wrapper_type_index = std::numeric_limits<int>::max();

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

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

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

SetIsolateErrorHandlers(isolate, settings);

SetIsolateMiscHandlers(isolate, settings);

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

explicit InspectorParentHandleImpl(

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

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

Isolate::DisallowJavascriptExecutionScope disallow_js(env->isolate(),

Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);

{

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

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

SealHandleScope seal_handle_scope(env->isolate());

env->set_stopping(true);

env->stop_sub_worker_contexts();

env->RunCleanup();

RunAtExit(env);

}

// This call needs to be made while the `Environment` is still alive

// because we assume that it is available for async tracking in the

// NodePlatform implementation.

MultiIsolatePlatform* platform = env->isolate_data()->platform();

if (platform != nullptr)

platform->DrainTasks(env->isolate());

delete env;

Environment* env,

StartExecutionCallback cb) {

env->InitializeLibuv();

env->InitializeDiagnostics();

return StartExecution(env, cb);

Environment* env,

const char* main_script_source_utf8) {

CHECK_NOT_NULL(main_script_source_utf8);

return LoadEnvironment(

env,

[&](const StartExecutionCallbackInfo& info) -> MaybeLocal<Value> {

// This is a slightly hacky way to convert UTF-8 to UTF-16.

Local<String> str =

String::NewFromUtf8(env->isolate(),

main_script_source_utf8).ToLocalChecked();

auto main_utf16 = std::make_unique<String::Value>(env->isolate(), str);

// TODO(addaleax): Avoid having a global table for all scripts.

std::string name = "embedder_main_" + std::to_string(env->thread_id());

native_module::NativeModuleEnv::Add(

name.c_str(),

UnionBytes(**main_utf16, main_utf16->length()));

env->set_main_utf16(std::move(main_utf16));

std::vector<Local<String>> params = {

env->process_string(),

env->require_string()};

std::vector<Local<Value>> args = {

env->process_object(),

env->native_module_require()};

return ExecuteBootstrapper(env, name.c_str(), &params, &args);

});

int thread_pool_size,

v8::TracingController* tracing_controller) {

return std::make_unique<NodePlatform>(thread_pool_size, tracing_controller);

Isolate* isolate = context->GetIsolate();

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

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

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

!InitializePrimordials(context))

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

return Local<Context>();

}

return context;

Isolate* isolate = context->GetIsolate();

HandleScope handle_scope(isolate);

// Delete `Intl.v8BreakIterator`

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

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

intl_v->IsObject()) {

Local<Object> intl = intl_v.As<Object>();

intl->Delete(context, break_iter_string).Check();

}

// Delete `Atomics.wake`

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

Local<String> atomics_string = FIXED_ONE_BYTE_STRING(isolate, "Atomics");

Local<String> wake_string = FIXED_ONE_BYTE_STRING(isolate, "wake");

Local<Value> atomics_v;

if (context->Global()->Get(context, atomics_string).ToLocal(&atomics_v) &&

atomics_v->IsObject()) {

Local<Object> atomics = atomics_v.As<Object>();

atomics->Delete(context, wake_string).Check();

}

// Remove __proto__

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

Local<String> object_string = FIXED_ONE_BYTE_STRING(isolate, "Object");

Local<String> prototype_string = FIXED_ONE_BYTE_STRING(isolate, "prototype");

Local<Object> prototype = context->Global()

->Get(context, object_string)

.ToLocalChecked()

.As<Object>()

->Get(context, prototype_string)

.ToLocalChecked()

.As<Object>();

Local<String> proto_string = FIXED_ONE_BYTE_STRING(isolate, "__proto__");

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

prototype->Delete(context, proto_string).ToChecked();

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

Local<Value> thrower =

Function::New(context, ProtoThrower).ToLocalChecked();

PropertyDescriptor descriptor(thrower, thrower);

descriptor.set_enumerable(false);

descriptor.set_configurable(true);

prototype->DefineProperty(context, proto_string, descriptor).ToChecked();

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

// Validated in ProcessGlobalArgs

FatalError("InitializeContextRuntime()", "invalid --disable-proto mode");

}

Isolate* isolate = context->GetIsolate();

HandleScope handle_scope(isolate);

context->SetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration,

True(isolate));

return InitializePrimordials(context);

// Run per-context JS files.

Isolate* isolate = context->GetIsolate();

Context::Scope context_scope(context);

Local<Object> exports;

Local<String> primordials_string =

FIXED_ONE_BYTE_STRING(isolate, "primordials");

Local<String> global_string = FIXED_ONE_BYTE_STRING(isolate, "global");

Local<String> exports_string = FIXED_ONE_BYTE_STRING(isolate, "exports");

// Create primordials first and make it available to per-context scripts.

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

if (!primordials->SetPrototype(context, Null(isolate)).FromJust() ||

!GetPerContextExports(context).ToLocal(&exports) ||

!exports->Set(context, primordials_string, primordials).FromJust()) {

return false;

}

static const char* context_files[] = {"internal/per_context/primordials",

"internal/per_context/domexception",

"internal/per_context/messageport",

nullptr};

for (const char** module = context_files; *module != nullptr; module++) {

std::vector<Local<String>> parameters = {

global_string, exports_string, primordials_string};

Local<Value> arguments[] = {context->Global(), exports, primordials};

MaybeLocal<Function> maybe_fn =

native_module::NativeModuleEnv::LookupAndCompile(

context, *module, &parameters, nullptr);

Local<Function> fn;

if (!maybe_fn.ToLocal(&fn)) {

return false;

}

MaybeLocal<Value> result =

fn->Call(context, Undefined(isolate), arraysize(arguments), arguments);

// Execution failed during context creation.

// TODO(joyeecheung): deprecate this signature and return a MaybeLocal.

if (result.IsEmpty()) {

return false;

}

}

return true;

if (!InitializeContextForSnapshot(context)) {

return false;

}

InitializeContextRuntime(context);

return true;

CHECK_NOT_NULL(env);

Mutex::ScopedLock lock(env->extra_linked_bindings_mutex());

node_module* prev_head = env->extra_linked_bindings_head();

env->extra_linked_bindings()->push_back(mod);

if (prev_head != nullptr)

prev_head->nm_link = &env->extra_linked_bindings()->back();

const char* name,

addon_context_register_func fn,

void* priv) {

node_module mod = {

NODE_MODULE_VERSION,

NM_F_LINKED,

nullptr, // nm_dso_handle

nullptr, // nm_filename

nullptr, // nm_register_func

fn,

name,

priv,

nullptr // nm_link

};

AddLinkedBinding(env, mod);

env->set_can_call_into_js(false);

env->stop_sub_worker_contexts();

DisposePlatform();

uv_library_shutdown();

exit(exit_code);