Local<Function> before,

Local<Function> after,

Local<Function> resolve) {

js_promise_hooks_[0].Reset(env()->isolate(), init);

js_promise_hooks_[1].Reset(env()->isolate(), before);

js_promise_hooks_[2].Reset(env()->isolate(), after);

js_promise_hooks_[3].Reset(env()->isolate(), resolve);

v8::LocalVector<Value> values(isolate, js_promise_hooks_.size());

for (size_t i = 0; i < js_promise_hooks_.size(); ++i) {

if (js_promise_hooks_[i].IsEmpty()) {

values[i] = Undefined(isolate);

} else {

values[i] = js_promise_hooks_[i].Get(isolate);

}

}

return Array::New(isolate, values.data(), values.size());

Local<Function> before,

Local<Function> after,

Local<Function> resolve) {

async_hooks()->ResetPromiseHooks(init, before, after, resolve);

for (auto it = contexts_.begin(); it != contexts_.end(); it++) {

if (it->IsEmpty()) {

contexts_.erase(it--);

continue;

}

PersistentToLocal::Weak(isolate_, *it)

->SetPromiseHooks(init, before, after, resolve);

}

double async_id,

double trigger_async_id,

std::variant<Local<Object>*, Global<Object>*> resource) {

std::visit([](auto* ptr) { CHECK_IMPLIES(ptr != nullptr, !ptr->IsEmpty()); },

resource);

if (fields_[kCheck] > 0) {

CHECK_GE(async_id, -1);

CHECK_GE(trigger_async_id, -1);

}

uint32_t offset = fields_[kStackLength];

if (offset * 2 >= async_ids_stack_.Length()) grow_async_ids_stack();

async_ids_stack_[2 * offset] = async_id_fields_[kExecutionAsyncId];

async_ids_stack_[2 * offset + 1] = async_id_fields_[kTriggerAsyncId];

fields_[kStackLength] += 1;

async_id_fields_[kExecutionAsyncId] = async_id;

async_id_fields_[kTriggerAsyncId] = trigger_async_id;

#ifdef DEBUG

for (uint32_t i = offset; i < native_execution_async_resources_.size(); i++)

std::visit([](auto* ptr) { CHECK_NULL(ptr); },

native_execution_async_resources_[i]);

#endif

// When this call comes from JS (as a way of increasing the stack size),

// `resource` will be empty, because JS caches these values anyway.

// False positive: https://github.com/cpplint/cpplint/issues/410

// NOLINTNEXTLINE(whitespace/newline)

if (std::visit([](auto* ptr) { return ptr != nullptr; }, resource)) {

native_execution_async_resources_.resize(offset + 1);

// Caveat: This is a v8::Local<>* assignment, we do not keep a v8::Global<>!

native_execution_async_resources_[offset] = resource;

}

// In case of an exception then this may have already been reset, if the

// stack was multiple MakeCallback()'s deep.

if (fields_[kStackLength] == 0) [[unlikely]]

return false;

// Ask for the async_id to be restored as a check that the stack

// hasn't been corrupted.

if (fields_[kCheck] > 0 && async_id_fields_[kExecutionAsyncId] != async_id)

[[unlikely]] {

FailWithCorruptedAsyncStack(async_id);

}

uint32_t offset = fields_[kStackLength] - 1;

async_id_fields_[kExecutionAsyncId] = async_ids_stack_[2 * offset];

async_id_fields_[kTriggerAsyncId] = async_ids_stack_[2 * offset + 1];

fields_[kStackLength] = offset;

if (offset < native_execution_async_resources_.size() &&

std::visit([](auto* ptr) { return ptr != nullptr; },

native_execution_async_resources_[offset])) [[likely]] {

#ifdef DEBUG

for (uint32_t i = offset + 1; i < native_execution_async_resources_.size();

i++) {

std::visit([](auto* ptr) { CHECK_NULL(ptr); },

native_execution_async_resources_[i]);

}

#endif

native_execution_async_resources_.resize(offset);

native_execution_async_resources_.shrink_to_fit();

}

if (js_execution_async_resources()->Length() > offset) [[unlikely]] {

HandleScope handle_scope(env()->isolate());

USE(js_execution_async_resources()->Set(

env()->context(),

env()->length_string(),

Integer::NewFromUnsigned(env()->isolate(), offset)));

}

return fields_[kStackLength] > 0;

if (!js_execution_async_resources_.IsEmpty() && env()->can_call_into_js()) {

Isolate* isolate = env()->isolate();

HandleScope handle_scope(isolate);

USE(PersistentToLocal::Strong(js_execution_async_resources_)

->Set(env()->context(),

env()->length_string(),

Integer::NewFromUnsigned(isolate, 0)));

}

native_execution_async_resources_.clear();

native_execution_async_resources_.shrink_to_fit();

async_id_fields_[kExecutionAsyncId] = 0;

async_id_fields_[kTriggerAsyncId] = 0;

fields_[kStackLength] = 0;

ctx->SetPromiseHooks(js_promise_hooks_[0].IsEmpty()

? Local<Function>()

: PersistentToLocal::Strong(js_promise_hooks_[0]),

js_promise_hooks_[1].IsEmpty()

? Local<Function>()

: PersistentToLocal::Strong(js_promise_hooks_[1]),

js_promise_hooks_[2].IsEmpty()

? Local<Function>()

: PersistentToLocal::Strong(js_promise_hooks_[2]),

js_promise_hooks_[3].IsEmpty()

? Local<Function>()

: PersistentToLocal::Strong(js_promise_hooks_[3]));

PurgeTrackedEmptyContexts();

size_t id = contexts_.size();

contexts_.resize(id + 1);

contexts_[id].Reset(isolate_, context);

contexts_[id].SetWeak();

HandleScope handle_scope(isolate_);

PurgeTrackedEmptyContexts();

for (auto it = contexts_.begin(); it != contexts_.end(); it++) {

if (Local<Context> saved_context = PersistentToLocal::Weak(isolate_, *it);

saved_context == context) {

it->Reset();

contexts_.erase(it);

break;

}

}

Isolate* isolate = creator->GetIsolate();

IsolateDataSerializeInfo info;

HandleScope handle_scope(isolate);

// XXX(joyeecheung): technically speaking, the indexes here should be

// consecutive and we could just return a range instead of an array,

// but that's not part of the V8 API contract so we use an array

// just to be safe.

#define VP(PropertyName, StringValue) V(Private, PropertyName)

#define VY(PropertyName, StringValue) V(Symbol, PropertyName)

#define VS(PropertyName, StringValue) V(String, PropertyName)

#define VR(PropertyName, TypeName) V(Private, per_realm_##PropertyName)

#define V(TypeName, PropertyName) \

info.primitive_values.push_back( \

creator->AddData(PropertyName##_.Get(isolate)));

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_SYMBOL_PROPERTIES(VY)

PER_ISOLATE_STRING_PROPERTIES(VS)

PER_REALM_STRONG_PERSISTENT_VALUES(VR)

#undef V

#undef VR

#undef VY

#undef VS

#undef VP

#define V(Name, label, _, __) \

info.primitive_values.push_back( \

creator->AddData(Name##_permission_string##_.Get(isolate)));

PERMISSIONS(V)

#undef V

info.primitive_values.reserve(info.primitive_values.size() +

AsyncWrap::PROVIDERS_LENGTH);

for (size_t i = 0; i < AsyncWrap::PROVIDERS_LENGTH; i++) {

info.primitive_values.push_back(creator->AddData(async_wrap_provider(i)));

}

uint32_t id = 0;

#define VM(PropertyName) V(PropertyName##_binding_template, ObjectTemplate)

#define V(PropertyName, TypeName) \

do { \

Local<TypeName> field = PropertyName(); \

if (!field.IsEmpty()) { \

size_t index = creator->AddData(field); \

info.template_values.push_back({#PropertyName, id, index}); \

} \

id++; \

} while (0);

PER_ISOLATE_TEMPLATE_PROPERTIES(V)

NODE_BINDINGS_WITH_PER_ISOLATE_INIT(VM)

#undef V

return info;

size_t i = 0;

Isolate::Scope isolate_scope(isolate_);

HandleScope handle_scope(isolate_);

if (per_process::enabled_debug_list.enabled(DebugCategory::MKSNAPSHOT)) {

fprintf(stderr, "deserializing IsolateDataSerializeInfo...\n");

std::cerr << *info << "\n";

}

#define VP(PropertyName, StringValue) V(Private, PropertyName)

#define VY(PropertyName, StringValue) V(Symbol, PropertyName)

#define VS(PropertyName, StringValue) V(String, PropertyName)

#define VR(PropertyName, TypeName) V(Private, per_realm_##PropertyName)

#define V(TypeName, PropertyName) \

do { \

MaybeLocal<TypeName> maybe_field = \

isolate_->GetDataFromSnapshotOnce<TypeName>( \

info->primitive_values[i++]); \

Local<TypeName> field; \

if (!maybe_field.ToLocal(&field)) { \

fprintf(stderr, "Failed to deserialize " #PropertyName "\n"); \

} \

PropertyName##_.Set(isolate_, field); \

} while (0);

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_SYMBOL_PROPERTIES(VY)

PER_ISOLATE_STRING_PROPERTIES(VS)

PER_REALM_STRONG_PERSISTENT_VALUES(VR)

#undef V

#undef VR

#undef VY

#undef VS

#undef VP

#define V(Name, label, _, __) \

do { \

MaybeLocal<String> maybe_field = \

isolate_->GetDataFromSnapshotOnce<String>( \

info->primitive_values[i++]); \

Local<String> field; \

if (!maybe_field.ToLocal(&field)) { \

fprintf(stderr, "Failed to deserialize " #Name "_permission_string\n"); \

} \

Name##_permission_string##_.Set(isolate_, field); \

} while (0);

PERMISSIONS(V)

#undef V

for (size_t j = 0; j < AsyncWrap::PROVIDERS_LENGTH; j++) {

MaybeLocal<String> maybe_field =

isolate_->GetDataFromSnapshotOnce<String>(info->primitive_values[i++]);

Local<String> field;

if (!maybe_field.ToLocal(&field)) {

fprintf(stderr, "Failed to deserialize AsyncWrap provider %zu\n", j);

}

async_wrap_providers_[j].Set(isolate_, field);

}

const std::vector<PropInfo>& values = info->template_values;

i = 0; // index to the array

uint32_t id = 0;

#define VM(PropertyName) V(PropertyName##_binding_template, ObjectTemplate)

#define V(PropertyName, TypeName) \

do { \

if (values.size() > i && id == values[i].id) { \

const PropInfo& d = values[i]; \

DCHECK_EQ(d.name, #PropertyName); \

MaybeLocal<TypeName> maybe_field = \

isolate_->GetDataFromSnapshotOnce<TypeName>(d.index); \

Local<TypeName> field; \

if (!maybe_field.ToLocal(&field)) { \

fprintf(stderr, \

"Failed to deserialize isolate data template " #PropertyName \

"\n"); \

} \

set_##PropertyName(field); \

i++; \

} \

id++; \

} while (0);

PER_ISOLATE_TEMPLATE_PROPERTIES(V);

NODE_BINDINGS_WITH_PER_ISOLATE_INIT(VM);

#undef V

// Create string and private symbol properties as internalized one byte

// strings after the platform is properly initialized.

//

// Internalized because it makes property lookups a little faster and

// because the string is created in the old space straight away. It's going

// to end up in the old space sooner or later anyway but now it doesn't go

// through v8::Eternal's new space handling first.

//

// One byte because our strings are ASCII and we can safely skip V8's UTF-8

// decoding step.

v8::Isolate::Scope isolate_scope(isolate_);

HandleScope handle_scope(isolate_);

#define V(PropertyName, StringValue) \

PropertyName##_.Set( \

isolate_, \

Private::New(isolate_, \

String::NewFromOneByte( \

isolate_, \

reinterpret_cast<const uint8_t*>(StringValue), \

NewStringType::kInternalized, \

sizeof(StringValue) - 1) \

.ToLocalChecked()));

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)

#undef V

#define V(PropertyName, TypeName) \

per_realm_##PropertyName##_.Set( \

isolate_, \

Private::New( \

isolate_, \

String::NewFromOneByte( \

isolate_, \

reinterpret_cast<const uint8_t*>("per_realm_" #PropertyName), \

NewStringType::kInternalized, \

sizeof("per_realm_" #PropertyName) - 1) \

.ToLocalChecked()));

PER_REALM_STRONG_PERSISTENT_VALUES(V)

#undef V

#define V(PropertyName, StringValue) \

PropertyName##_.Set( \

isolate_, \

Symbol::New(isolate_, \

String::NewFromOneByte( \

isolate_, \

reinterpret_cast<const uint8_t*>(StringValue), \

NewStringType::kInternalized, \

sizeof(StringValue) - 1) \

.ToLocalChecked()));

PER_ISOLATE_SYMBOL_PROPERTIES(V)

#undef V

#define V(PropertyName, StringValue) \

PropertyName##_.Set( \

isolate_, \

String::NewFromOneByte(isolate_, \

reinterpret_cast<const uint8_t*>(StringValue), \

NewStringType::kInternalized, \

sizeof(StringValue) - 1) \

.ToLocalChecked());

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

#define V(Name, label, _, __) \

Name##_permission_string##_.Set( \

isolate_, \

String::NewFromOneByte(isolate_, \

reinterpret_cast<const uint8_t*>(#Name), \

NewStringType::kInternalized, \

sizeof(#Name) - 1) \

.ToLocalChecked());

PERMISSIONS(V)

#undef V

// Create all the provider strings that will be passed to JS. Place them in

// an array so the array index matches the PROVIDER id offset. This way the

// strings can be retrieved quickly.

#define V(Provider) \

async_wrap_providers_[AsyncWrap::PROVIDER_ ## Provider].Set( \

isolate_, \

String::NewFromOneByte( \

isolate_, \

reinterpret_cast<const uint8_t*>(#Provider), \

NewStringType::kInternalized, \

sizeof(#Provider) - 1).ToLocalChecked());

NODE_ASYNC_PROVIDER_TYPES(V)

#undef V

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

templ->SetInternalFieldCount(BaseObject::kInternalFieldCount);

set_binding_data_default_template(templ);

binding::CreateInternalBindingTemplates(this);

contextify::ContextifyContext::InitializeGlobalTemplates(this);

CreateEnvProxyTemplate(this);

uv_loop_t* event_loop,

MultiIsolatePlatform* platform,

ArrayBufferAllocator* node_allocator,

const SnapshotData* snapshot_data,

std::shared_ptr<PerIsolateOptions> options)

: isolate_(isolate),

event_loop_(event_loop),

node_allocator_(node_allocator == nullptr ? nullptr

: node_allocator->GetImpl()),

platform_(platform),

snapshot_data_(snapshot_data),

options_(std::move(options)) {

uint16_t cppgc_id = kDefaultCppGCEmbedderID;

// We do not care about overflow since we just want this to be different

// from the cppgc id.

uint16_t non_cppgc_id = cppgc_id + 1;

{

// GC could still be run after the IsolateData is destroyed, so we store

// the ids in a static map to ensure pointers to them are still valid

// then. In practice there should be very few variants of the cppgc id

// in one process so the size of this map should be very small.

node::Mutex::ScopedLock lock(isolate_data_mutex_);

auto it = wrapper_data_map_.find(cppgc_id);

if (it == wrapper_data_map_.end()) {

auto pair = wrapper_data_map_.emplace(

cppgc_id, new PerIsolateWrapperData{cppgc_id, non_cppgc_id});

it = pair.first;

}

wrapper_data_ = it->second.get();

}

if (snapshot_data == nullptr) {

CreateProperties();

} else {

DeserializeProperties(&snapshot_data->isolate_data_info);

}

Local<Object> object,

v8::Object::Wrappable* wrappable) {

v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(

isolate, object, wrappable);

#define V(PropertyName, StringValue) \

tracker->TrackField(#PropertyName, PropertyName());

PER_ISOLATE_SYMBOL_PROPERTIES(V)

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

#define V(Name, label, _, __) \

tracker->TrackField(#Name "_permission_string", Name##_permission_string());

PERMISSIONS(V)

#undef V

tracker->TrackField("async_wrap_providers", async_wrap_providers_);

if (node_allocator_ != nullptr) {

tracker->TrackFieldWithSize(

"node_allocator", sizeof(*node_allocator_), "NodeArrayBufferAllocator");

}

tracker->TrackFieldWithSize(

"platform", sizeof(*platform_), "MultiIsolatePlatform");

// TODO(joyeecheung): implement MemoryRetainer in the option classes.

if (!env_->owns_process_state() || !env_->can_call_into_js()) {

// Ideally, we’d have a consistent story that treats all threads/Environment

// instances equally here. However, tracing is essentially global, and this

// callback is called from whichever thread calls `StartTracing()` or

// `StopTracing()`. The only way to do this in a threadsafe fashion

// seems to be only tracking this from the main thread, and only allowing

// these state modifications from the main thread.

return;

}

if (env_->principal_realm() == nullptr) {

return;

}

bool async_hooks_enabled = (*(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(

TRACING_CATEGORY_NODE1(async_hooks)))) != 0;

Isolate* isolate = env_->isolate();

HandleScope handle_scope(isolate);

Local<Function> cb = env_->trace_category_state_function();

if (cb.IsEmpty())

return;

TryCatchScope try_catch(env_);

try_catch.SetVerbose(true);

Local<Value> args[] = {Boolean::New(isolate, async_hooks_enabled)};

USE(cb->Call(env_->context(), Undefined(isolate), arraysize(args), args));

Realm* realm,

const ContextInfo& info) {

context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kEnvironment,

this,

EmbedderDataTag::kPerContextData);

context->SetAlignedPointerInEmbedderData(

ContextEmbedderIndex::kRealm, realm, EmbedderDataTag::kPerContextData);

// ContextifyContexts will update this to a pointer to the native object.

context->SetAlignedPointerInEmbedderData(

ContextEmbedderIndex::kContextifyContext,

nullptr,

EmbedderDataTag::kPerContextData);

// This must not be done before other context fields are initialized.

ContextEmbedderTag::TagNodeContext(context);

#if HAVE_INSPECTOR

inspector_agent()->ContextCreated(context, info);

#endif // HAVE_INSPECTOR

this->async_hooks()->InstallPromiseHooks(context);

TrackContext(context);

if (!context.IsEmpty()) {

context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kEnvironment,

nullptr,

EmbedderDataTag::kPerContextData);

context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kRealm,

nullptr,

EmbedderDataTag::kPerContextData);

context->SetAlignedPointerInEmbedderData(

ContextEmbedderIndex::kContextifyContext,

nullptr,

EmbedderDataTag::kPerContextData);

}

UntrackContext(context);

const char* filename,

int flags,

const std::function<bool(binding::DLib*)>& was_loaded) {

loaded_addons_.emplace_back(filename, flags);

if (!was_loaded(&loaded_addons_.back())) {

loaded_addons_.pop_back();

}

char cwd[PATH_MAX_BYTES];

size_t size = PATH_MAX_BYTES;

if (uv_cwd(cwd, &size) == 0) {

CHECK_GT(size, 0);

return cwd;

}

// This can fail if the cwd is deleted. In that case, fall back to

// exec_path.

return exec_path.substr(0, exec_path.find_last_of(kPathSeparator));

task_queues_async_refs_ += diff;

CHECK_GE(task_queues_async_refs_, 0);

if (task_queues_async_refs_ == 0)

uv_unref(reinterpret_cast<uv_handle_t*>(&task_queues_async_));

else

uv_ref(reinterpret_cast<uv_handle_t*>(&task_queues_async_));

std::unique_ptr<BackingStore> bs;

if (suggested_size == kManagedBufferCacheSize &&

managed_buffer_cache_ != nullptr) {

bs = std::move(managed_buffer_cache_);

} else {

bs = ArrayBuffer::NewBackingStore(

isolate(),

suggested_size,

BackingStoreInitializationMode::kUninitialized);

}

uv_buf_t buf = uv_buf_init(static_cast<char*>(bs->Data()), bs->ByteLength());

released_allocated_buffers_.emplace(buf.base, std::move(bs));

return buf;

const uv_buf_t& buf) {

std::unique_ptr<BackingStore> bs;

if (buf.base != nullptr) {

auto it = released_allocated_buffers_.find(buf.base);

CHECK_NE(it, released_allocated_buffers_.end());

bs = std::move(it->second);

released_allocated_buffers_.erase(it);

}

return bs;

DCHECK_GT(suggested, 0);

// Reads always get the full `suggested` size: handing out a smaller

// remainder would shrink the read() buffer and fragment large reads into

// more system calls, which costs more than the slab tail it saves.

size_t remaining = current_.bs ? current_.size() - current_.offset : 0;

if (remaining < suggested) {

// Retire the current slab; it stays alive through `retired_` if reads

// are still pending on it, or through JS views over it otherwise.

if (current_.bs && current_.pending > 0)

retired_.push_back(std::move(current_));

current_ = Slab();

std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(

isolate,

std::max(kSlabSize, suggested),

BackingStoreInitializationMode::kUninitialized);

current_.bs = std::move(bs);

}

char* base = current_.data() + current_.offset;

current_.offset += suggested;

current_.last_base = base;

current_.last_end = current_.offset;

current_.pending++;

return uv_buf_init(base, suggested);

const uv_buf_t& buf,

size_t used) {

DCHECK_GT(slab->pending, 0);

slab->pending--;

if (buf.base == slab->last_base && slab->offset == slab->last_end) {

// This was the most recent reservation and nothing was reserved after

// it: rewind the unused remainder so it can be reserved again.

slab->offset = (buf.base - slab->data()) + used;

slab->last_end = slab->offset;

}

if (slab != &current_ && slab->pending == 0) {

for (auto it = retired_.begin(); it != retired_.end(); ++it) {

if (&*it == slab) {

retired_.erase(it);

break;

}

}

}

const uv_buf_t& buf,

size_t nread,

Local<ArrayBuffer>* ab,

size_t* offset) {

Slab* slab = FindSlab(buf.base);

if (slab == nullptr) return false;

DCHECK_LE(nread, buf.len);

// A partial read would leave the rest of its reservation as waste once

// the slab retires - memory that counts towards V8's external memory and

// drives up GC frequency. If most of the reservation would be wasted,

// give the read a right-sized copy instead (as if it had never been read

// into the slab) and return its reservation in full. Reads that (mostly)

// fill their reservation get a zero-copy view into the slab.

if (nread < buf.len - buf.len / 4 && buf.base == slab->last_base &&

slab->offset == slab->last_end) {

std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(

isolate, nread, BackingStoreInitializationMode::kUninitialized);

memcpy(bs->Data(), buf.base, nread);

*ab = ArrayBuffer::New(isolate, std::move(bs));

*offset = 0;

CompleteReservation(slab, buf, 0);

return true;

}

*offset = buf.base - slab->data();

if (slab->ab.IsEmpty()) {

*ab = ArrayBuffer::New(isolate, slab->bs);

slab->ab.Reset(isolate, *ab);

} else {

*ab = slab->ab.Get(isolate);

}

CompleteReservation(slab, buf, nread);

return true;

if (buf.base == nullptr) return true;

Slab* slab = FindSlab(buf.base);

if (slab == nullptr) return false;

CompleteReservation(slab, buf, 0);

return true;

char exec_path_buf[2 * PATH_MAX];

size_t exec_path_len = sizeof(exec_path_buf);

std::string exec_path;

if (uv_exepath(exec_path_buf, &exec_path_len) == 0) {

exec_path = std::string(exec_path_buf, exec_path_len);

} else if (!argv.empty()) {

exec_path = argv[0];

}

// On OpenBSD process.execPath will be relative unless we

// get the full path before process.execPath is used.

#if defined(__OpenBSD__)

uv_fs_t req;

req.ptr = nullptr;

if (0 ==

uv_fs_realpath(nullptr, &req, exec_path.c_str(), nullptr)) {

CHECK_NOT_NULL(req.ptr);

exec_path = std::string(static_cast<char*>(req.ptr));

}

uv_fs_req_cleanup(&req);

#endif

return exec_path;

Isolate* isolate,

const std::vector<std::string>& args,

const std::vector<std::string>& exec_args,

const EnvSerializeInfo* env_info,

EnvironmentFlags::Flags flags,

ThreadId thread_id,

std::string_view thread_name)

: isolate_(isolate),

external_memory_accounter_(std::make_unique<ExternalMemoryAccounter>()),

isolate_data_(isolate_data),

async_hooks_(isolate, MAYBE_FIELD_PTR(env_info, async_hooks)),

immediate_info_(isolate, MAYBE_FIELD_PTR(env_info, immediate_info)),

timeout_info_(isolate_, 1, MAYBE_FIELD_PTR(env_info, timeout_info)),

tick_info_(isolate, MAYBE_FIELD_PTR(env_info, tick_info)),

timer_base_(uv_now(isolate_data->event_loop())),

exec_argv_(exec_args),

argv_(args),

exec_path_(Environment::GetExecPath(args)),

exit_info_(

isolate_, kExitInfoFieldCount, MAYBE_FIELD_PTR(env_info, exit_info)),

should_abort_on_uncaught_toggle_(

isolate_,

1,

MAYBE_FIELD_PTR(env_info, should_abort_on_uncaught_toggle)),

stream_base_state_(isolate_,

StreamBase::kNumStreamBaseStateFields,

MAYBE_FIELD_PTR(env_info, stream_base_state)),

time_origin_(performance::performance_process_start),

time_origin_timestamp_(performance::performance_process_start_timestamp),

environment_start_(PERFORMANCE_NOW()),

flags_(flags),

thread_id_(thread_id.id == static_cast<uint64_t>(-1)

? AllocateEnvironmentThreadId().id

: thread_id.id),

thread_name_(thread_name) {

#if HAVE_OPENSSL && NCRYPTO_USE_OPENSSL3_PROVIDER

provider_digest_cache = std::make_unique<ncrypto::DigestCache>();

provider_cipher_cache = std::make_unique<ncrypto::CipherCache>();

#if OPENSSL_WITH_EVP_MAC

provider_mac_cache = std::make_unique<ncrypto::MacCache>();

#endif

#endif

if (!is_main_thread()) {

// If this is a Worker thread, we can always safely use the parent's

// Isolate's code cache because of the shared read-only heap.

CHECK_NOT_NULL(isolate_data->worker_context());

builtin_loader()->CopySourceAndCodeCacheReferenceFrom(

isolate_data->worker_context()->env()->builtin_loader());

} else if (isolate_data->snapshot_data() != nullptr) {