src: make code cache test work with snapshots

Keep track of snapshotted modules in JS land, and move
bootstrap switches into StartExecution() so that
they are not included into part of the environment-independent
bootstrap process.

Author: joyeecheung

lib/internal/bootstrap/node.js

@@ -57,7 +57,8 @@ process.domain = null;
 process._exiting = false;
 
 // process.config is serialized config.gypi
-process.config = JSONParse(internalBinding('native_module').config);
+const nativeModule = internalBinding('native_module');
+process.config = JSONParse(nativeModule.config);
 
 // Bootstrappers for all threads, including worker threads and main thread
 const perThreadSetup = require('internal/process/per_thread');
@@ -184,21 +185,28 @@ process.assert = deprecate(
 // TODO(joyeecheung): this property has not been well-maintained, should we
 // deprecate it in favor of a better API?
 const { isDebugBuild, hasOpenSSL, hasInspector } = config;
+const features = {
+  inspector: hasInspector,
+  debug: isDebugBuild,
+  uv: true,
+  ipv6: true,  // TODO(bnoordhuis) ping libuv
+  tls_alpn: hasOpenSSL,
+  tls_sni: hasOpenSSL,
+  tls_ocsp: hasOpenSSL,
+  tls: hasOpenSSL,
+  // This needs to be dynamic because snapshot is built without code cache.
+  // TODO(joyeecheung): https://github.com/nodejs/node/issues/31074
+  // Make it possible to build snapshot with code cache
+  get cached_builtins() {
+    return nativeModule.hasCachedBuiltins();
+  }
+};
+
 ObjectDefineProperty(process, 'features', {
   enumerable: true,
   writable: false,
   configurable: false,
-  value: {
-    inspector: hasInspector,
-    debug: isDebugBuild,
-    uv: true,
-    ipv6: true,  // TODO(bnoordhuis) ping libuv
-    tls_alpn: hasOpenSSL,
-    tls_sni: hasOpenSSL,
-    tls_ocsp: hasOpenSSL,
-    tls: hasOpenSSL,
-    cached_builtins: config.hasCachedBuiltins,
-  }
+  value: features
 });
 
 {

src/env.cc

@@ -1256,6 +1256,12 @@ EnvSerializeInfo Environment::Serialize(SnapshotCreator* creator) {
   EnvSerializeInfo info;
   Local<Context> ctx = context();
 
+  // Currently all modules are compiled without cache in snapshot builder
+  std::vector<std::string> modules_in_snapshot(
+      native_modules_without_cache.begin(), native_modules_without_cache.end());
+  Local<Value> arr = ToV8Value(ctx, modules_in_snapshot).ToLocalChecked();
+  set_native_module_in_snapshot(arr.As<v8::Array>());
+
   NoBindingData* data =
       BindingDataBase::Unwrap<NoBindingData>(ctx, default_callback_data());
   info.default_callback_data = creator->AddData(ctx, data->object());

src/env.h

@@ -456,6 +456,7 @@ constexpr size_t kFsStatsBufferLength =
   V(immediate_callback_function, v8::Function)                                 \
   V(inspector_console_extension_installer, v8::Function)                       \
   V(message_port, v8::Object)                                                  \
+  V(native_module_in_snapshot, v8::Array)                                      \
   V(native_module_require, v8::Function)                                       \
   V(performance_entry_callback, v8::Function)                                  \
   V(performance_entry_template, v8::Function)                                  \

src/node.cc

@@ -308,6 +308,7 @@ MaybeLocal<Value> Environment::BootstrapNode() {
     return scope.EscapeMaybe(result);
   }
 
+  // TODO(joyeecheung): skip these in the snapshot building for workers.
   auto thread_switch_id =
       is_main_thread() ? "internal/bootstrap/switches/is_main_thread"
                        : "internal/bootstrap/switches/is_not_main_thread";

src/node_config.cc

@@ -84,9 +84,6 @@ static void Initialize(Local<Object> target,
 #if defined HAVE_DTRACE || defined HAVE_ETW
   READONLY_TRUE_PROPERTY(target, "hasDtrace");
 #endif
-
-  READONLY_PROPERTY(target, "hasCachedBuiltins",
-     v8::Boolean::New(isolate, native_module::has_code_cache));
 }  // InitConfig
 
 }  // namespace node

src/node_native_module_env.cc

@@ -95,6 +95,19 @@ void NativeModuleEnv::GetCacheUsage(const FunctionCallbackInfo<Value>& args) {
             OneByteString(isolate, "compiledWithoutCache"),
             ToJsSet(context, env->native_modules_without_cache))
       .FromJust();
+
+  Local<Value> native_module_in_snapshot;
+  if (env->native_module_in_snapshot().IsEmpty()) {
+    native_module_in_snapshot = v8::Array::New(isolate);
+  } else {
+    native_module_in_snapshot = env->native_module_in_snapshot();
+  }
+  result
+      ->Set(env->context(),
+            OneByteString(isolate, "compiledInSnapshot"),
+            native_module_in_snapshot)
+      .FromJust();
+
   args.GetReturnValue().Set(result);
 }
 
@@ -155,6 +168,11 @@ MaybeLocal<Function> NativeModuleEnv::LookupAndCompile(
   return maybe;
 }
 
+void HasCachedBuiltins(const FunctionCallbackInfo<Value>& args) {
+  args.GetReturnValue().Set(
+      v8::Boolean::New(args.GetIsolate(), has_code_cache));
+}
+
 // TODO(joyeecheung): It is somewhat confusing that Class::Initialize
 // is used to initialize to the binding, but it is the current convention.
 // Rename this across the code base to something that makes more sense.
@@ -198,6 +216,7 @@ void NativeModuleEnv::Initialize(Local<Object> target,
 
   env->SetMethod(target, "getCacheUsage", NativeModuleEnv::GetCacheUsage);
   env->SetMethod(target, "compileFunction", NativeModuleEnv::CompileFunction);
+  env->SetMethod(target, "hasCachedBuiltins", HasCachedBuiltins);
   // internalBinding('native_module') should be frozen
   target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
 }

test/parallel/test-code-cache.js

@@ -22,12 +22,16 @@ for (const key of canBeRequired) {
 // The computation has to be delayed until we have done loading modules
 const {
   compiledWithoutCache,
-  compiledWithCache
+  compiledWithCache,
+  compiledInSnapshot
 } = getCacheUsage();
 
-const loadedModules = process.moduleLoadList
-  .filter((m) => m.startsWith('NativeModule'))
+function extractModules(list) {
+  return list.filter((m) => m.startsWith('NativeModule'))
   .map((m) => m.replace('NativeModule ', ''));
+}
+
+const loadedModules = extractModules(process.moduleLoadList);
 
 // Cross-compiled binaries do not have code cache, verifies that the builtins
 // are all compiled without cache and we are doing the bookkeeping right.
@@ -62,7 +66,9 @@ if (!process.features.cached_builtins) {
     if (cannotBeRequired.has(key) && !compiledWithoutCache.has(key)) {
       wrong.push(`"${key}" should've been compiled **without** code cache`);
     }
-    if (canBeRequired.has(key) && !compiledWithCache.has(key)) {
+    if (canBeRequired.has(key) &&
+      !compiledWithCache.has(key) &&
+      compiledInSnapshot.indexOf(key) === -1) {
       wrong.push(`"${key}" should've been compiled **with** code cache`);
     }
   }