Skip to content

Commit 0778599

Browse files
joyeecheungjoyeecheung
committed
src: split RunBootstrapping()
Split `RunBootstrapping()` into `BootstrapInternalLoaders()` and `BootstrapNode()` from so the two can be snapshotted incrementally. PR-URL: #27539 Reviewed-By: Anna Henningsen <anna@addaleax.net>
1 parent a0d86be commit 0778599

6 files changed

Lines changed: 82 additions & 68 deletions

File tree

‎src/api/environment.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -287,7 +287,7 @@ Environment* CreateEnvironment(IsolateData* isolate_data,
287287
Environment::kOwnsProcessState |
288288
Environment::kOwnsInspector));
289289
env->InitializeLibuv(per_process::v8_is_profiling);
290-
if (RunBootstrapping(env).IsEmpty()) {
290+
if (env->RunBootstrapping().IsEmpty()) {
291291
return nullptr;
292292
}
293293

‎src/env.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -809,6 +809,10 @@ class Environment : public MemoryRetainer {
809809
int InitializeInspector(inspector::ParentInspectorHandle* parent_handle);
810810
#endif
811811

812+
v8::MaybeLocal<v8::Value> BootstrapInternalLoaders();
813+
v8::MaybeLocal<v8::Value> BootstrapNode();
814+
v8::MaybeLocal<v8::Value> RunBootstrapping();
815+
812816
inline size_t async_callback_scope_depth() const;
813817
inline void PushAsyncCallbackScope();
814818
inline void PopAsyncCallbackScope();

‎src/node.cc‎

Lines changed: 75 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,6 @@ using options_parser::kAllowedInEnvironment;
130130
using options_parser::kDisallowedInEnvironment;
131131

132132
using v8::Boolean;
133-
using v8::Context;
134133
using v8::EscapableHandleScope;
135134
using v8::Exception;
136135
using v8::Function;
@@ -277,99 +276,111 @@ void Environment::InitializeDiagnostics() {
277276
#endif
278277
}
279278

280-
MaybeLocal<Value> RunBootstrapping(Environment* env) {
281-
CHECK(!env->has_run_bootstrapping_code());
282-
283-
EscapableHandleScope scope(env->isolate());
284-
Isolate* isolate = env->isolate();
285-
Local<Context> context = env->context();
286-
287-
288-
// Add a reference to the global object
289-
Local<Object> global = context->Global();
290-
Local<Object> process = env->process_object();
291-
292-
// Setting global properties for the bootstrappers to use:
293-
// - global
294-
// Expose the global object as a property on itself
295-
// (Allows you to set stuff on `global` from anywhere in JavaScript.)
296-
global->Set(context, FIXED_ONE_BYTE_STRING(env->isolate(), "global"), global)
297-
.Check();
298-
279+
MaybeLocal<Value> Environment::BootstrapInternalLoaders() {
280+
EscapableHandleScope scope(isolate_);
299281

300282
// Create binding loaders
301283
std::vector<Local<String>> loaders_params = {
302-
env->process_string(),
303-
FIXED_ONE_BYTE_STRING(isolate, "getLinkedBinding"),
304-
FIXED_ONE_BYTE_STRING(isolate, "getInternalBinding"),
305-
env->primordials_string()};
284+
process_string(),
285+
FIXED_ONE_BYTE_STRING(isolate_, "getLinkedBinding"),
286+
FIXED_ONE_BYTE_STRING(isolate_, "getInternalBinding"),
287+
primordials_string()};
306288
std::vector<Local<Value>> loaders_args = {
307-
process,
308-
env->NewFunctionTemplate(binding::GetLinkedBinding)
309-
->GetFunction(context)
289+
process_object(),
290+
NewFunctionTemplate(binding::GetLinkedBinding)
291+
->GetFunction(context())
310292
.ToLocalChecked(),
311-
env->NewFunctionTemplate(binding::GetInternalBinding)
312-
->GetFunction(context)
293+
NewFunctionTemplate(binding::GetInternalBinding)
294+
->GetFunction(context())
313295
.ToLocalChecked(),
314-
env->primordials()};
296+
primordials()};
315297

316298
// Bootstrap internal loaders
317-
MaybeLocal<Value> loader_exports = ExecuteBootstrapper(
318-
env, "internal/bootstrap/loaders", &loaders_params, &loaders_args);
319-
if (loader_exports.IsEmpty()) {
299+
Local<Value> loader_exports;
300+
if (!ExecuteBootstrapper(
301+
this, "internal/bootstrap/loaders", &loaders_params, &loaders_args)
302+
.ToLocal(&loader_exports)) {
320303
return MaybeLocal<Value>();
321304
}
322-
323-
Local<Object> loader_exports_obj =
324-
loader_exports.ToLocalChecked().As<Object>();
305+
CHECK(loader_exports->IsObject());
306+
Local<Object> loader_exports_obj = loader_exports.As<Object>();
325307
Local<Value> internal_binding_loader =
326-
loader_exports_obj->Get(context, env->internal_binding_string())
308+
loader_exports_obj->Get(context(), internal_binding_string())
327309
.ToLocalChecked();
328-
env->set_internal_binding_loader(internal_binding_loader.As<Function>());
329-
310+
CHECK(internal_binding_loader->IsFunction());
311+
set_internal_binding_loader(internal_binding_loader.As<Function>());
330312
Local<Value> require =
331-
loader_exports_obj->Get(context, env->require_string()).ToLocalChecked();
332-
env->set_native_module_require(require.As<Function>());
313+
loader_exports_obj->Get(context(), require_string()).ToLocalChecked();
314+
CHECK(require->IsFunction());
315+
set_native_module_require(require.As<Function>());
316+
317+
return scope.Escape(loader_exports);
318+
}
319+
320+
MaybeLocal<Value> Environment::BootstrapNode() {
321+
EscapableHandleScope scope(isolate_);
322+
323+
Local<Object> global = context()->Global();
324+
// TODO(joyeecheung): this can be done in JS land now.
325+
global->Set(context(), FIXED_ONE_BYTE_STRING(isolate_, "global"), global)
326+
.Check();
333327

334328
// process, require, internalBinding, isMainThread,
335329
// ownsProcessState, primordials
336330
std::vector<Local<String>> node_params = {
337-
env->process_string(),
338-
env->require_string(),
339-
env->internal_binding_string(),
340-
FIXED_ONE_BYTE_STRING(isolate, "isMainThread"),
341-
FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
342-
env->primordials_string()};
331+
process_string(),
332+
require_string(),
333+
internal_binding_string(),
334+
FIXED_ONE_BYTE_STRING(isolate_, "isMainThread"),
335+
FIXED_ONE_BYTE_STRING(isolate_, "ownsProcessState"),
336+
primordials_string()};
343337
std::vector<Local<Value>> node_args = {
344-
process,
345-
require,
346-
internal_binding_loader,
347-
Boolean::New(isolate, env->is_main_thread()),
348-
Boolean::New(isolate, env->owns_process_state()),
349-
env->primordials()};
338+
process_object(),
339+
native_module_require(),
340+
internal_binding_loader(),
341+
Boolean::New(isolate_, is_main_thread()),
342+
Boolean::New(isolate_, owns_process_state()),
343+
primordials()};
350344

351345
MaybeLocal<Value> result = ExecuteBootstrapper(
352-
env, "internal/bootstrap/node", &node_params, &node_args);
346+
this, "internal/bootstrap/node", &node_params, &node_args);
353347

354348
Local<Object> env_var_proxy;
355-
if (!CreateEnvVarProxy(context, isolate, env->as_callback_data())
349+
if (!CreateEnvVarProxy(context(), isolate_, as_callback_data())
356350
.ToLocal(&env_var_proxy) ||
357-
process
358-
->Set(env->context(),
359-
FIXED_ONE_BYTE_STRING(env->isolate(), "env"),
360-
env_var_proxy)
361-
.IsNothing())
351+
process_object()
352+
->Set(
353+
context(), FIXED_ONE_BYTE_STRING(isolate_, "env"), env_var_proxy)
354+
.IsNothing()) {
355+
return MaybeLocal<Value>();
356+
}
357+
358+
return scope.EscapeMaybe(result);
359+
}
360+
361+
MaybeLocal<Value> Environment::RunBootstrapping() {
362+
EscapableHandleScope scope(isolate_);
363+
364+
CHECK(!has_run_bootstrapping_code());
365+
366+
if (BootstrapInternalLoaders().IsEmpty()) {
367+
return MaybeLocal<Value>();
368+
}
369+
370+
Local<Value> result;
371+
if (!BootstrapNode().ToLocal(&result)) {
362372
return MaybeLocal<Value>();
373+
}
363374

364375
// Make sure that no request or handle is created during bootstrap -
365376
// if necessary those should be done in pre-execution.
366377
// TODO(joyeecheung): print handles/requests before aborting
367-
CHECK(env->req_wrap_queue()->IsEmpty());
368-
CHECK(env->handle_wrap_queue()->IsEmpty());
378+
CHECK(req_wrap_queue()->IsEmpty());
379+
CHECK(handle_wrap_queue()->IsEmpty());
369380

370-
env->set_has_run_bootstrapping_code(true);
381+
set_has_run_bootstrapping_code(true);
371382

372-
return scope.EscapeMaybe(result);
383+
return scope.Escape(result);
373384
}
374385

375386
void MarkBootstrapComplete(const FunctionCallbackInfo<Value>& args) {

‎src/node_internals.h‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -275,7 +275,6 @@ void DefineZlibConstants(v8::Local<v8::Object> target);
275275
v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
276276
uv_loop_t* event_loop,
277277
MultiIsolatePlatform* platform);
278-
v8::MaybeLocal<v8::Value> RunBootstrapping(Environment* env);
279278
v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
280279
const char* main_script_id);
281280
v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);

‎src/node_main_instance.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,7 @@ std::unique_ptr<Environment> NodeMainInstance::CreateMainEnvironment(
205205
return env;
206206
}
207207

208-
if (RunBootstrapping(env.get()).IsEmpty()) {
208+
if (env->RunBootstrapping().IsEmpty()) {
209209
*exit_code = 1;
210210
}
211211

‎src/node_worker.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -271,7 +271,7 @@ void Worker::Run() {
271271
HandleScope handle_scope(isolate_);
272272
AsyncCallbackScope callback_scope(env_.get());
273273
env_->async_hooks()->push_async_ids(1, 0);
274-
if (!RunBootstrapping(env_.get()).IsEmpty()) {
274+
if (!env_->RunBootstrapping().IsEmpty()) {
275275
CreateEnvMessagePort(env_.get());
276276
if (is_stopped()) return;
277277
Debug(this, "Created message port for worker %llu", thread_id_);

0 commit comments

Comments
 (0)