src: collect external references for snapshot

Gather external references from the different native modules that
are loaded during bootstrapping, for inclusion in the snapshot.

Author: addaleax

node.gyp

@@ -616,6 +616,7 @@
         'src/pipe_wrap.cc',
         'src/process_wrap.cc',
         'src/signal_wrap.cc',
+        'src/snapshot_support.cc',
         'src/spawn_sync.cc',
         'src/stream_base.cc',
         'src/stream_pipe.cc',
@@ -707,6 +708,8 @@
         'src/pipe_wrap.h',
         'src/req_wrap.h',
         'src/req_wrap-inl.h',
+        'src/snapshot_support.h',
+        'src/snapshot_support-inl.h',
         'src/spawn_sync.h',
         'src/stream_base.h',
         'src/stream_base-inl.h',

src/async_wrap.cc

@@ -24,6 +24,7 @@
 #include "env-inl.h"
 #include "node_errors.h"
 #include "tracing/traced_value.h"
+#include "snapshot_support-inl.h"
 #include "util-inl.h"
 
 #include "v8.h"
@@ -580,6 +581,23 @@ void AsyncWrap::Initialize(Local<Object> target,
           ->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  SetupHooks,
+  AsyncWrap::PushAsyncContext,
+  AsyncWrap::PopAsyncContext,
+  AsyncWrap::QueueDestroyAsyncId,
+  EnablePromiseHook,
+  DisablePromiseHook,
+  RegisterDestroyHook,
+  AsyncWrapObject::New,
+  AsyncWrap::GetAsyncId,
+  // AsyncReset is overloaded, pick the right one
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(
+      AsyncWrap::AsyncReset),
+  AsyncWrap::GetProviderType,
+  PromiseWrap::getIsChainedPromise,
+};
 
 AsyncWrap::AsyncWrap(Environment* env,
                      Local<Object> object,

src/inspector_js_api.cc

@@ -2,6 +2,7 @@
 #include "inspector_agent.h"
 #include "inspector_io.h"
 #include "memory_tracker-inl.h"
+#include "snapshot_support-inl.h"
 #include "util-inl.h"
 #include "v8.h"
 #include "v8-inspector.h"
@@ -345,6 +346,31 @@ void Initialize(Local<Object> target, Local<Value> unused,
   JSBindingsConnection<MainThreadConnection>::Bind(env, target);
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  InspectorConsoleCall,
+  SetConsoleExtensionInstaller,
+  CallAndPauseOnStart,
+  Open,
+  Url,
+  WaitForDebugger,
+  AsyncTaskScheduledWrapper,
+  InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>,
+  InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>,
+  InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>,
+  RegisterAsyncHookWrapper,
+  IsEnabled,
+  JSBindingsConnection<LocalConnection>::New,
+  JSBindingsConnection<LocalConnection>::Dispatch,
+  // Disconnect is overloaded, pick the right one
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(
+      JSBindingsConnection<LocalConnection>::Disconnect),
+  JSBindingsConnection<MainThreadConnection>::New,
+  JSBindingsConnection<MainThreadConnection>::Dispatch,
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(
+      JSBindingsConnection<MainThreadConnection>::Disconnect),
+};
+
 }  // namespace
 }  // namespace inspector
 }  // namespace node

src/node.cc

@@ -39,6 +39,7 @@
 #include "node_revert.h"
 #include "node_v8_platform-inl.h"
 #include "node_version.h"
+#include "snapshot_support-inl.h"
 
 #if HAVE_OPENSSL
 #include "node_crypto.h"
@@ -1028,16 +1029,14 @@ int Start(int argc, char** argv) {
   {
     Isolate::CreateParams params;
     const std::vector<size_t>* indexes = nullptr;
-    std::vector<intptr_t> external_references;
+    std::vector<intptr_t> external_references = ExternalReferences::get_list();
+    external_references.push_back(ExternalReferences::kEnd);
 
     bool force_no_snapshot =
         per_process::cli_options->per_isolate->no_node_snapshot;
     if (!force_no_snapshot) {
       v8::StartupData* blob = NodeMainInstance::GetEmbeddedSnapshotBlob();
       if (blob != nullptr) {
-        // TODO(joyeecheung): collect external references and set it in
-        // params.external_references.
-        external_references.push_back(reinterpret_cast<intptr_t>(nullptr));
         params.external_references = external_references.data();
         params.snapshot_blob = blob;
         indexes = NodeMainInstance::GetIsolateDataIndexes();
@@ -1062,6 +1061,14 @@ int Stop(Environment* env) {
   return 0;
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  binding::GetLinkedBinding,
+  binding::GetInternalBinding,
+  MarkBootstrapComplete,
+};
+
+
 }  // namespace node
 
 #if !HAVE_INSPECTOR

src/node_buffer.cc

@@ -28,6 +28,7 @@
 #include "string_bytes.h"
 #include "string_search.h"
 #include "util-inl.h"
+#include "snapshot_support-inl.h"
 #include "v8.h"
 
 #include <cstring>
@@ -1222,6 +1223,37 @@ void Initialize(Local<Object> target,
   }
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  SetBufferPrototype,
+  CreateFromString,
+  ByteLengthUtf8,
+  Copy,
+  Compare,
+  CompareOffset,
+  Fill,
+  IndexOfBuffer,
+  IndexOfNumber,
+  IndexOfString,
+  Swap16,
+  Swap32,
+  Swap64,
+  EncodeInto,
+  EncodeUtf8String,
+  StringSlice<ASCII>,
+  StringSlice<BASE64>,
+  StringSlice<LATIN1>,
+  StringSlice<HEX>,
+  StringSlice<UCS2>,
+  StringSlice<UTF8>,
+  StringWrite<ASCII>,
+  StringWrite<BASE64>,
+  StringWrite<LATIN1>,
+  StringWrite<HEX>,
+  StringWrite<UCS2>,
+  StringWrite<UTF8>,
+};
+
 }  // anonymous namespace
 }  // namespace Buffer
 }  // namespace node

src/node_credentials.cc

@@ -1,5 +1,6 @@
 #include "env-inl.h"
 #include "node_internals.h"
+#include "snapshot_support-inl.h"
 #include "util-inl.h"
 
 #ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
@@ -401,6 +402,25 @@ static void Initialize(Local<Object> target,
 #endif  // NODE_IMPLEMENTS_POSIX_CREDENTIALS
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  // SafeGetenv is overloaded, pick the right one
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(SafeGetenv),
+#ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
+  GetUid,
+  GetEUid,
+  GetGid,
+  GetEGid,
+  GetGroups,
+  InitGroups,
+  SetEGid,
+  SetEUid,
+  SetGid,
+  SetUid,
+  SetGroups,
+#endif
+};
+
 }  // namespace credentials
 }  // namespace node
 

src/node_env_var.cc

@@ -2,6 +2,7 @@
 #include "env-inl.h"
 #include "node_errors.h"
 #include "node_process.h"
+#include "snapshot_support-inl.h"
 
 #include <time.h>  // tzset(), _tzset()
 
@@ -385,4 +386,15 @@ MaybeLocal<Object> CreateEnvVarProxy(Local<Context> context, Isolate* isolate) {
       PropertyHandlerFlags::kHasNoSideEffect));
   return scope.EscapeMaybe(env_proxy_template->NewInstance(context));
 }
+
+
+static ExternalReferences external_references {
+  __FILE__,
+  EnvGetter,
+  EnvSetter,
+  EnvQuery,
+  EnvDeleter,
+  EnvEnumerator
+};
+
 }  // namespace node

src/node_errors.cc

@@ -7,6 +7,7 @@
 #include "node_report.h"
 #include "node_process.h"
 #include "node_v8_platform-inl.h"
+#include "snapshot_support-inl.h"
 #include "util-inl.h"
 
 namespace node {
@@ -848,6 +849,16 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "triggerUncaughtException", TriggerUncaughtException);
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  SetPrepareStackTraceCallback,
+  SetEnhanceStackForFatalException,
+  NoSideEffectsToString,
+  // TriggerUncaughtException is overloaded, pick the right one
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(
+      TriggerUncaughtException),
+};
+
 void DecorateErrorStack(Environment* env,
                         const errors::TryCatchScope& try_catch) {
   Local<Value> exception = try_catch.Exception();

src/node_i18n.cc

@@ -49,6 +49,7 @@
 #include "node_buffer.h"
 #include "node_errors.h"
 #include "node_internals.h"
+#include "snapshot_support-inl.h"
 #include "util-inl.h"
 #include "v8.h"
 
@@ -825,6 +826,20 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "hasConverter", ConverterObject::Has);
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  // Pick the right variant for overloaded names.
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(ToUnicode),
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(ToASCII),
+  GetStringWidth,
+  ICUErrorName,
+  static_cast<void(*)(const FunctionCallbackInfo<Value>& args)>(Transcode),
+  ConverterObject::Create,
+  ConverterObject::Decode,
+  ConverterObject::Has,
+};
+
+
 }  // namespace i18n
 }  // namespace node
 

src/node_native_module_env.cc

@@ -1,4 +1,5 @@
 #include "node_native_module_env.h"
+#include "snapshot_support-inl.h"
 #include "env-inl.h"
 
 namespace node {
@@ -202,6 +203,15 @@ void NativeModuleEnv::Initialize(Local<Object> target,
   target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
 }
 
+static ExternalReferences external_references {
+  __FILE__,
+  NativeModuleEnv::ConfigStringGetter,
+  NativeModuleEnv::ModuleIdsGetter,
+  NativeModuleEnv::GetModuleCategories,
+  NativeModuleEnv::GetCacheUsage,
+  NativeModuleEnv::CompileFunction,
+};
+
 }  // namespace native_module
 }  // namespace node