Isolate* isolate = creator->GetIsolate();

std::vector<size_t> indexes;

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 V(TypeName, PropertyName) \

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

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_SYMBOL_PROPERTIES(VY)

PER_ISOLATE_STRING_PROPERTIES(VS)

#undef V

#undef VY

#undef VS

#undef VP

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

indexes.push_back(creator->AddData(async_wrap_provider(i)));

return indexes;

size_t i = 0;

HandleScope handle_scope(isolate_);

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

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

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

#define V(TypeName, PropertyName) \

do { \

MaybeLocal<TypeName> field = \

isolate_->GetDataFromSnapshotOnce<TypeName>((*indexes)[i++]); \

if (field.IsEmpty()) { \

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

} \

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

} while (0);

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_SYMBOL_PROPERTIES(VY)

PER_ISOLATE_STRING_PROPERTIES(VS)

#undef V

#undef VY

#undef VS

#undef VP

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

MaybeLocal<String> field =

isolate_->GetDataFromSnapshotOnce<String>((*indexes)[i++]);

if (field.IsEmpty()) {

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

}

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

}

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

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

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

uv_loop_t* event_loop,

MultiIsolatePlatform* platform,

ArrayBufferAllocator* node_allocator,

const std::vector<size_t>* indexes)

: isolate_(isolate),

event_loop_(event_loop),

allocator_(isolate->GetArrayBufferAllocator()),

node_allocator_(node_allocator == nullptr ? nullptr

: node_allocator->GetImpl()),

uses_node_allocator_(allocator_ == node_allocator_),

platform_(platform) {

CHECK_NOT_NULL(allocator_);

options_.reset(

new PerIsolateOptions(*(per_process::cli_options->per_isolate)));

if (indexes == nullptr) {

CreateProperties();

} else {

DeserializeProperties(indexes);

}

#define V(PropertyName, StringValue) \

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

PER_ISOLATE_SYMBOL_PROPERTIES(V)

#undef V

#define V(PropertyName, StringValue) \

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

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

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

if (node_allocator_ != nullptr) {

tracker->TrackFieldWithSize(

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

} else {

tracker->TrackFieldWithSize(

"allocator", sizeof(*allocator_), "v8::ArrayBuffer::Allocator");

}

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;

}

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

HandleScope handle_scope(isolate_);

Local<Context> ctx = context();

{

Context::Scope context_scope(ctx);

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

templ->InstanceTemplate()->SetInternalFieldCount(

BaseObject::kInternalFieldCount);

templ->Inherit(BaseObject::GetConstructorTemplate(this));

set_binding_data_ctor_template(templ);

}

// Store primordials setup by the per-context script in the environment.

Local<Object> per_context_bindings =

GetPerContextExports(ctx).ToLocalChecked();

Local<Value> primordials =

per_context_bindings->Get(ctx, primordials_string()).ToLocalChecked();

CHECK(primordials->IsObject());

set_primordials(primordials.As<Object>());

Local<Object> process_object =

node::CreateProcessObject(this).FromMaybe(Local<Object>());

set_process_object(process_object);

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 {

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;

Local<Context> context,

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

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

EnvironmentFlags::Flags flags,

ThreadId thread_id)

: isolate_(context->GetIsolate()),

isolate_data_(isolate_data),

immediate_info_(context->GetIsolate()),

tick_info_(context->GetIsolate()),

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

exec_argv_(exec_args),

argv_(args),

exec_path_(GetExecPath(args)),

should_abort_on_uncaught_toggle_(isolate_, 1),

stream_base_state_(isolate_, StreamBase::kNumStreamBaseStateFields),

flags_(flags),

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

AllocateEnvironmentThreadId().id : thread_id.id),

context_(context->GetIsolate(), context) {

// We'll be creating new objects so make sure we've entered the context.

HandleScope handle_scope(isolate());

Context::Scope context_scope(context);

// Set some flags if only kDefaultFlags was passed. This can make API version

// transitions easier for embedders.

if (flags_ & EnvironmentFlags::kDefaultFlags) {

flags_ = flags_ |

EnvironmentFlags::kOwnsProcessState |

EnvironmentFlags::kOwnsInspector;

}

set_env_vars(per_process::system_environment);

enabled_debug_list_.Parse(this);

// We create new copies of the per-Environment option sets, so that it is

// easier to modify them after Environment creation. The defaults are

// part of the per-Isolate option set, for which in turn the defaults are

// part of the per-process option set.

options_.reset(new EnvironmentOptions(*isolate_data->options()->per_env));

inspector_host_port_.reset(

new ExclusiveAccess<HostPort>(options_->debug_options().host_port));

#if HAVE_INSPECTOR

// We can only create the inspector agent after having cloned the options.

inspector_agent_ = std::make_unique<inspector::Agent>(this);

#endif

AssignToContext(context, ContextInfo(""));

static uv_once_t init_once = UV_ONCE_INIT;

uv_once(&init_once, InitThreadLocalOnce);

uv_key_set(&thread_local_env, this);

if (tracing::AgentWriterHandle* writer = GetTracingAgentWriter()) {

trace_state_observer_ = std::make_unique<TrackingTraceStateObserver>(this);

if (TracingController* tracing_controller = writer->GetTracingController())

tracing_controller->AddTraceStateObserver(trace_state_observer_.get());

}

destroy_async_id_list_.reserve(512);

performance_state_ =

std::make_unique<performance::PerformanceState>(isolate());

performance_state_->Mark(

performance::NODE_PERFORMANCE_MILESTONE_ENVIRONMENT);

performance_state_->Mark(performance::NODE_PERFORMANCE_MILESTONE_NODE_START,

per_process::node_start_time);

performance_state_->Mark(

performance::NODE_PERFORMANCE_MILESTONE_V8_START,

performance::performance_v8_start);

if (*TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(

TRACING_CATEGORY_NODE1(environment)) != 0) {

auto traced_value = tracing::TracedValue::Create();

traced_value->BeginArray("args");

for (const std::string& arg : args) traced_value->AppendString(arg);

traced_value->EndArray();

traced_value->BeginArray("exec_args");

for (const std::string& arg : exec_args) traced_value->AppendString(arg);

traced_value->EndArray();

TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(TRACING_CATEGORY_NODE1(environment),

"Environment",

this,

"args",

std::move(traced_value));

}

// By default, always abort when --abort-on-uncaught-exception was passed.

should_abort_on_uncaught_toggle_[0] = 1;

if (options_->no_force_async_hooks_checks) {

async_hooks_.no_force_checks();

}

// TODO(joyeecheung): deserialize when the snapshot covers the environment

// properties.

CreateProperties();

// This adjusts the return value of base_object_count() so that tests that

// check the count do not have to account for internally created BaseObjects.

initial_base_object_count_ = base_object_count();

HandleScope handle_scope(isolate());

Context::Scope context_scope(context());

CHECK_EQ(0, uv_timer_init(event_loop(), timer_handle()));

uv_unref(reinterpret_cast<uv_handle_t*>(timer_handle()));

uv_check_init(event_loop(), immediate_check_handle());

uv_unref(reinterpret_cast<uv_handle_t*>(immediate_check_handle()));

uv_idle_init(event_loop(), immediate_idle_handle());

uv_check_start(immediate_check_handle(), CheckImmediate);

uv_async_init(

event_loop(),

&task_queues_async_,

[](uv_async_t* async) {

Environment* env = ContainerOf(

&Environment::task_queues_async_, async);

env->RunAndClearNativeImmediates();

});

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

{

Mutex::ScopedLock lock(native_immediates_threadsafe_mutex_);

task_queues_async_initialized_ = true;

if (native_immediates_threadsafe_.size() > 0 ||

native_immediates_interrupts_.size() > 0) {

uv_async_send(&task_queues_async_);

}

}

// Register clean-up cb to be called to clean up the handles

// when the environment is freed, note that they are not cleaned in

// the one environment per process setup, but will be called in

// FreeEnvironment.

RegisterHandleCleanups();

set_can_call_into_js(false);

set_stopping(true);

isolate_->TerminateExecution();

SetImmediateThreadsafe([](Environment* env) { uv_stop(env->event_loop()); });

HandleCleanupCb close_and_finish = [](Environment* env, uv_handle_t* handle,

void* arg) {

handle->data = env;

env->CloseHandle(handle, [](uv_handle_t* handle) {

#ifdef DEBUG

memset(handle, 0xab, uv_handle_size(handle->type));

#endif

});

};

auto register_handle = [&](uv_handle_t* handle) {

RegisterHandleCleanup(handle, close_and_finish, nullptr);

};

register_handle(reinterpret_cast<uv_handle_t*>(timer_handle()));

register_handle(reinterpret_cast<uv_handle_t*>(immediate_check_handle()));

register_handle(reinterpret_cast<uv_handle_t*>(immediate_idle_handle()));

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

{

Mutex::ScopedLock lock(native_immediates_threadsafe_mutex_);

task_queues_async_initialized_ = false;

}

Isolate::DisallowJavascriptExecutionScope disallow_js(isolate(),

Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);

RunAndClearNativeImmediates(true /* skip unrefed SetImmediate()s */);

for (ReqWrapBase* request : req_wrap_queue_)

request->Cancel();

for (HandleWrap* handle : handle_wrap_queue_)

handle->Close();

for (HandleCleanup& hc : handle_cleanup_queue_)

hc.cb_(this, hc.handle_, hc.arg_);

handle_cleanup_queue_.clear();

while (handle_cleanup_waiting_ != 0 ||

request_waiting_ != 0 ||

!handle_wrap_queue_.IsEmpty()) {

uv_run(event_loop(), UV_RUN_ONCE);

}

if (!trace_sync_io_) return;

HandleScope handle_scope(isolate());

fprintf(

stderr, "(node:%d) WARNING: Detected use of sync API\n", uv_os_getpid());

PrintStackTrace(isolate(),

StackTrace::CurrentStackTrace(

isolate(), stack_trace_limit(), StackTrace::kDetailed));

started_cleanup_ = true;

TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),

"RunCleanup", this);

bindings_.clear();

initial_base_object_count_ = 0;

CleanupHandles();

while (!cleanup_hooks_.empty()) {

// Copy into a vector, since we can't sort an unordered_set in-place.

std::vector<CleanupHookCallback> callbacks(

cleanup_hooks_.begin(), cleanup_hooks_.end());

// We can't erase the copied elements from `cleanup_hooks_` yet, because we

// need to be able to check whether they were un-scheduled by another hook.

std::sort(callbacks.begin(), callbacks.end(),

[](const CleanupHookCallback& a, const CleanupHookCallback& b) {

// Sort in descending order so that the most recently inserted callbacks

// are run first.

return a.insertion_order_counter_ > b.insertion_order_counter_;

});

for (const CleanupHookCallback& cb : callbacks) {

if (cleanup_hooks_.count(cb) == 0) {

// This hook was removed from the `cleanup_hooks_` set during another

// hook that was run earlier. Nothing to do here.

continue;

}

cb.fn_(cb.arg_);

cleanup_hooks_.erase(cb);

}

CleanupHandles();

}

TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),

"AtExit", this);

for (ExitCallback at_exit : at_exit_functions_) {

at_exit.cb_(at_exit.arg_);

}

at_exit_functions_.clear();

while (native_immediates_interrupts_.size() > 0) {

NativeImmediateQueue queue;

{

Mutex::ScopedLock lock(native_immediates_threadsafe_mutex_);

queue.ConcatMove(std::move(native_immediates_interrupts_));

}

DebugSealHandleScope seal_handle_scope(isolate());

while (auto head = queue.Shift())

head->Call(this);

}

TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),

"RunAndClearNativeImmediates", this);

size_t ref_count = 0;

// Handle interrupts first. These functions are not allowed to throw

// exceptions, so we do not need to handle that.

RunAndClearInterrupts();

auto drain_list = [&](NativeImmediateQueue* queue) {

TryCatchScope try_catch(this);

DebugSealHandleScope seal_handle_scope(isolate());

while (auto head = queue->Shift()) {

bool is_refed = head->flags() & CallbackFlags::kRefed;

if (is_refed)

ref_count++;

if (is_refed || !only_refed)

head->Call(this);

head.reset(); // Destroy now so that this is also observed by try_catch.

if (UNLIKELY(try_catch.HasCaught())) {

if (!try_catch.HasTerminated() && can_call_into_js())

errors::TriggerUncaughtException(isolate(), try_catch);

return true;

}

}

return false;

};

while (drain_list(&native_immediates_)) {}

immediate_info()->ref_count_dec(ref_count);

if (immediate_info()->ref_count() == 0)

ToggleImmediateRef(false);

// It is safe to check .size() first, because there is a causal relationship

// between pushes to the threadsafe immediate list and this function being

// called. For the common case, it's worth checking the size first before

// establishing a mutex lock.

// This is intentionally placed after the `ref_count` handling, because when

// refed threadsafe immediates are created, they are not counted towards the

// count in immediate_info() either.

NativeImmediateQueue threadsafe_immediates;

if (native_immediates_threadsafe_.size() > 0) {

Mutex::ScopedLock lock(native_immediates_threadsafe_mutex_);

threadsafe_immediates.ConcatMove(std::move(native_immediates_threadsafe_));

}

while (drain_list(&threadsafe_immediates)) {}

// The Isolate may outlive the Environment, so some logic to handle the

// situation in which the Environment is destroyed before the handler runs

// is required.

// We allocate a new pointer to a pointer to this Environment instance, and

// try to set it as interrupt_data_. If interrupt_data_ was already set, then

// callbacks are already scheduled to run and we can delete our own pointer

// and just return. If it was nullptr previously, the Environment** is stored;

// ~Environment sets the Environment* contained in it to nullptr, so that

// the callback can check whether ~Environment has already run and it is thus

// not safe to access the Environment instance itself.

Environment** interrupt_data = new Environment*(this);

Environment** dummy = nullptr;

if (!interrupt_data_.compare_exchange_strong(dummy, interrupt_data)) {

delete interrupt_data;

return; // Already scheduled.

}

isolate()->RequestInterrupt([](Isolate* isolate, void* data) {

std::unique_ptr<Environment*> env_ptr { static_cast<Environment**>(data) };

Environment* env = *env_ptr;

if (env == nullptr) {

// The Environment has already been destroyed. That should be okay; any

// callback added before the Environment shuts down would have been

// handled during cleanup.

return;

}

env->interrupt_data_.store(nullptr);

env->RunAndClearInterrupts();

}, interrupt_data);

if (started_cleanup_) return;

if (ref) {

uv_ref(reinterpret_cast<uv_handle_t*>(timer_handle()));

} else {

uv_unref(reinterpret_cast<uv_handle_t*>(timer_handle()));

}

Environment* env = Environment::from_timer_handle(handle);

TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),

"RunTimers", env);

if (!env->can_call_into_js())

return;

HandleScope handle_scope(env->isolate());

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

Local<Object> process = env->process_object();

InternalCallbackScope scope(env, process, {0, 0});

Local<Function> cb = env->timers_callback_function();

MaybeLocal<Value> ret;

Local<Value> arg = env->GetNow();

// This code will loop until all currently due timers will process. It is

// impossible for us to end up in an infinite loop due to how the JS-side

// is structured.

do {

TryCatchScope try_catch(env);

try_catch.SetVerbose(true);

ret = cb->Call(env->context(), process, 1, &arg);

} while (ret.IsEmpty() && env->can_call_into_js());

// NOTE(apapirovski): If it ever becomes possible that `call_into_js` above

// is reset back to `true` after being previously set to `false` then this

// code becomes invalid and needs to be rewritten. Otherwise catastrophic

// timers corruption will occur and all timers behaviour will become

// entirely unpredictable.

if (ret.IsEmpty())

return;

// To allow for less JS-C++ boundary crossing, the value returned from JS

// serves a few purposes:

// 1. If it's 0, no more timers exist and the handle should be unrefed

// 2. If it's > 0, the value represents the next timer's expiry and there

// is at least one timer remaining that is refed.

// 3. If it's < 0, the absolute value represents the next timer's expiry

// and there are no timers that are refed.

int64_t expiry_ms =

ret.ToLocalChecked()->IntegerValue(env->context()).FromJust();

uv_handle_t* h = reinterpret_cast<uv_handle_t*>(handle);

if (expiry_ms != 0) {

int64_t duration_ms =

llabs(expiry_ms) - (uv_now(env->event_loop()) - env->timer_base());

env->ScheduleTimer(duration_ms > 0 ? duration_ms : 1);

if (expiry_ms > 0)

uv_ref(h);

else

uv_unref(h);

} else {

uv_unref(h);

}

Environment* env = Environment::from_immediate_check_handle(handle);

TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),

"CheckImmediate", env);

HandleScope scope(env->isolate());

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

env->RunAndClearNativeImmediates();

if (env->immediate_info()->count() == 0 || !env->can_call_into_js())

return;

do {

MakeCallback(env->isolate(),

env->process_object(),

env->immediate_callback_function(),

0,

nullptr,

{0, 0}).ToLocalChecked();

} while (env->immediate_info()->has_outstanding() && env->can_call_into_js());

if (env->immediate_info()->ref_count() == 0)

env->ToggleImmediateRef(false);

if (started_cleanup_) return;

if (ref) {

// Idle handle is needed only to stop the event loop from blocking in poll.

uv_idle_start(immediate_idle_handle(), [](uv_idle_t*){ });

} else {

uv_idle_stop(immediate_idle_handle());

}

uv_update_time(event_loop());

uint64_t now = uv_now(event_loop());

CHECK_GE(now, timer_base());

now -= timer_base();

if (now <= 0xffffffff)

return Integer::NewFromUnsigned(isolate(), static_cast<uint32_t>(now));

else

return Number::New(isolate(), static_cast<double>(now));

Local<Object> obj,

int errorno,

const char* err_string,

const char* syscall,

const char* message,

const char* path,

const char* dest) {

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

env->errno_string(),

Integer::New(env->isolate(), errorno)).Check();

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

OneByteString(env->isolate(), err_string)).Check();

if (message != nullptr) {

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

OneByteString(env->isolate(), message)).Check();

}

Local<Value> path_buffer;

if (path != nullptr) {

path_buffer =

Buffer::Copy(env->isolate(), path, strlen(path)).ToLocalChecked();

obj->Set(env->context(), env->path_string(), path_buffer).Check();

}

Local<Value> dest_buffer;

if (dest != nullptr) {

dest_buffer =

Buffer::Copy(env->isolate(), dest, strlen(dest)).ToLocalChecked();

obj->Set(env->context(), env->dest_string(), dest_buffer).Check();

}

if (syscall != nullptr) {

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

OneByteString(env->isolate(), syscall)).Check();

}

int errorno,

const char* syscall,

const char* message,

const char* path,

const char* dest) {

if (!object->IsObject() || errorno == 0)

return;

Local<Object> obj = object.As<Object>();

const char* err_string = uv_err_name(errorno);

if (message == nullptr || message[0] == '\0') {

message = uv_strerror(errorno);

}

node::CollectExceptionInfo(this, obj, errorno, err_string,

syscall, message, path, dest);

tracker->TrackField("async_ids_stack", async_ids_stack_);

tracker->TrackField("fields", fields_);

tracker->TrackField("async_id_fields", async_id_fields_);

async_ids_stack_.reserve(async_ids_stack_.Length() * 3);

env()->async_hooks_binding()->Set(

env()->context(),

env()->async_ids_stack_string(),

async_ids_stack_.GetJSArray()).Check();

if (options()->trace_exit) {

HandleScope handle_scope(isolate());

if (is_main_thread()) {

fprintf(stderr, "(node:%d) ", uv_os_getpid());

} else {

fprintf(stderr, "(node:%d, thread:%" PRIu64 ") ",

uv_os_getpid(), thread_id());

}

fprintf(

stderr, "WARNING: Exited the environment with code %d\n", exit_code);

PrintStackTrace(isolate(),

StackTrace::CurrentStackTrace(

isolate(), stack_trace_limit(), StackTrace::kDetailed));

}

process_exit_handler_(this, exit_code);

DCHECK_EQ(Isolate::GetCurrent(), isolate());

while (!sub_worker_contexts_.empty()) {

Worker* w = *sub_worker_contexts_.begin();

remove_sub_worker_context(w);

w->Exit(1);

w->JoinThread();

}

EmbedderGraph* graph,

void* data) {

MemoryTracker tracker(isolate, graph);

Environment* env = static_cast<Environment*>(data);

tracker.Track(env);

env->ForEachBaseObject([&](BaseObject* obj) {

if (obj->IsDoneInitializing())

tracker.Track(obj);