src: use dedicated routine to compile function for builtin CJS loader

joyeecheung · joyeecheung · commit d62adb36cbdd · 2024-03-08T00:09:38.000+01:00
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
@@ -91,11 +91,13 @@ const {
   getLazy,
 } = require('internal/util');
 const {
-  internalCompileFunction,
   makeContextifyScript,
   runScriptInThisContext,
 } = require('internal/vm');
-const { containsModuleSyntax } = internalBinding('contextify');
+const {
+  containsModuleSyntax,
+  compileFunctionForCJSLoader,
+} = internalBinding('contextify');
 
 const assert = require('internal/assert');
 const fs = require('fs');
@@ -105,6 +107,7 @@ const { safeGetenv } = internalBinding('credentials');
 const {
   privateSymbols: {
     require_private_symbol,
+    host_defined_option_symbol,
   },
 } = internalBinding('util');
 const {
@@ -1274,23 +1277,11 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache) {
     return runScriptInThisContext(script, true, false);
   }
 
-  const params = [ 'exports', 'require', 'module', '__filename', '__dirname' ];
   try {
-    const result = internalCompileFunction(
-      content,                           // code,
-      filename,                          // filename
-      0,                                 // lineOffset
-      0,                                 // columnOffset,
-      codeCache,                         // cachedData
-      false,                             // produceCachedData
-      undefined,                         // parsingContext
-      undefined,                         // contextExtensions
-      params,                            // params
-      hostDefinedOptionId,               // hostDefinedOptionId
-      importModuleDynamically,           // importModuleDynamically
-    );
+    const result = compileFunctionForCJSLoader(content, filename);
+    result.function[host_defined_option_symbol] = hostDefinedOptionId;
 
-    // The code cache is used for SEAs only.
+    // cachedDataRejected is only set for cache coming from SEA.
     if (codeCache &&
         result.cachedDataRejected !== false &&
         internalBinding('sea').isSea()) {
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
@@ -19,6 +19,12 @@ const {
   globalThis: { WebAssembly },
 } = primordials;
 
+const {
+  privateSymbols: {
+    host_defined_option_symbol,
+  },
+} = internalBinding('util');
+
 /** @type {import('internal/util/types')} */
 let _TYPES = null;
 /**
@@ -29,7 +35,11 @@ function lazyTypes() {
   return _TYPES = require('internal/util/types');
 }
 
-const { containsModuleSyntax } = internalBinding('contextify');
+const {
+  containsModuleSyntax,
+  compileFunctionForCJSLoader,
+} = internalBinding('contextify');
+
 const { BuiltinModule } = require('internal/bootstrap/realm');
 const assert = require('internal/assert');
 const { readFileSync } = require('fs');
@@ -56,7 +66,6 @@ const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
 const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
 const { emitWarningSync } = require('internal/process/warning');
-const { internalCompileFunction } = require('internal/vm');
 const {
   vm_dynamic_import_default_internal,
 } = internalBinding('symbols');
@@ -210,28 +219,9 @@ function enrichCJSError(err, content, filename) {
  */
 function loadCJSModule(module, source, url, filename) {
   let compileResult;
-  const hostDefinedOptionId = vm_dynamic_import_default_internal;
-  const importModuleDynamically = vm_dynamic_import_default_internal;
   try {
-    compileResult = internalCompileFunction(
-      source,                         // code,
-      filename,                       // filename
-      0,                              // lineOffset
-      0,                              // columnOffset,
-      undefined,                      // cachedData
-      false,                          // produceCachedData
-      undefined,                      // parsingContext
-      undefined,                      // contextExtensions
-      [                               // params
-        'exports',
-        'require',
-        'module',
-        '__filename',
-        '__dirname',
-      ],
-      hostDefinedOptionId,           // hostDefinedOptionsId
-      importModuleDynamically,       // importModuleDynamically
-    );
+    compileResult = compileFunctionForCJSLoader(source, filename);
+    compileResult.function[host_defined_option_symbol] = vm_dynamic_import_default_internal;
   } catch (err) {
     enrichCJSError(err, source, filename);
     throw err;
diff --git a/lib/internal/util/embedding.js b/lib/internal/util/embedding.js
@@ -2,7 +2,7 @@
 const { BuiltinModule: { normalizeRequirableId } } = require('internal/bootstrap/realm');
 const { Module, wrapSafe } = require('internal/modules/cjs/loader');
 const { codes: { ERR_UNKNOWN_BUILTIN_MODULE } } = require('internal/errors');
-const { getCodeCache, getCodePath, isSea } = internalBinding('sea');
+const { getCodePath, isSea } = internalBinding('sea');
 
 // This is roughly the same as:
 //
@@ -18,9 +18,7 @@ function embedderRunCjs(contents) {
   const filename = process.execPath;
   const compiledWrapper = wrapSafe(
     isSea() ? getCodePath() : filename,
-    contents,
-    undefined,
-    getCodeCache());
+    contents);
 
   const customModule = new Module(filename, null);
   customModule.filename = filename;
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
@@ -28,6 +28,7 @@
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
+#include "node_sea.h"
 #include "node_snapshot_builder.h"
 #include "node_watchdog.h"
 #include "util-inl.h"
@@ -956,6 +957,15 @@ Maybe<bool> StoreCodeCacheResult(
   return Just(true);
 }
 
+static Local<PrimitiveArray> GetHostDefinedOptions(Isolate* isolate,
+                                                   Local<Symbol> id_symbol) {
+  Local<PrimitiveArray> host_defined_options =
+      PrimitiveArray::New(isolate, loader::HostDefinedOptions::kLength);
+  host_defined_options->Set(
+      isolate, loader::HostDefinedOptions::kID, id_symbol);
+  return host_defined_options;
+}
+
 // TODO(RaisinTen): Reuse in ContextifyContext::CompileFunction().
 MaybeLocal<Function> CompileFunction(Local<Context> context,
                                      Local<String> filename,
@@ -1280,15 +1290,6 @@ void ContextifyContext::CompileFunction(
   args.GetReturnValue().Set(result);
 }
 
-Local<PrimitiveArray> ContextifyContext::GetHostDefinedOptions(
-    Isolate* isolate, Local<Symbol> id_symbol) {
-  Local<PrimitiveArray> host_defined_options =
-      PrimitiveArray::New(isolate, loader::HostDefinedOptions::kLength);
-  host_defined_options->Set(
-      isolate, loader::HostDefinedOptions::kID, id_symbol);
-  return host_defined_options;
-}
-
 ScriptCompiler::Source ContextifyContext::GetCommonJSSourceInstance(
     Isolate* isolate,
     Local<String> code,
@@ -1485,6 +1486,102 @@ void ContextifyContext::ContainsModuleSyntax(
   args.GetReturnValue().Set(found_error_message_caused_by_module_syntax);
 }
 
+static void CompileFunctionForCJSLoader(
+    const FunctionCallbackInfo<Value>& args) {
+  CHECK(args[0]->IsString());
+  CHECK(args[1]->IsString());
+  Local<String> code = args[0].As<String>();
+  Local<String> filename = args[1].As<String>();
+  Isolate* isolate = args.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  Environment* env = Environment::GetCurrent(context);
+
+  Local<Symbol> symbol = env->vm_dynamic_import_default_internal();
+  Local<PrimitiveArray> hdo = GetHostDefinedOptions(isolate, symbol);
+  ScriptOrigin origin(isolate,
+                      filename,
+                      0,               // line offset
+                      0,               // column offset
+                      true,            // is cross origin
+                      -1,              // script id
+                      Local<Value>(),  // source map URL
+                      false,           // is opaque
+                      false,           // is WASM
+                      false,           // is ES Module
+                      hdo);
+  ScriptCompiler::CachedData* cached_data = nullptr;
+
+#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
+  bool used_cache_from_sea = false;
+  if (sea::IsSingleExecutable()) {
+    sea::SeaResource sea = sea::FindSingleExecutableResource();
+    if (sea.use_code_cache()) {
+      std::string_view data = sea.code_cache.value();
+      cached_data = new ScriptCompiler::CachedData(
+          reinterpret_cast<const uint8_t*>(data.data()),
+          static_cast<int>(data.size()),
+          v8::ScriptCompiler::CachedData::BufferNotOwned);
+      used_cache_from_sea = true;
+    }
+  }
+#endif
+  ScriptCompiler::Source source(code, origin, cached_data);
+
+  TryCatchScope try_catch(env);
+
+  // TODO(joyeecheung): make it a per-realm persistent.
+  std::vector<Local<String>> params = {
+      FIXED_ONE_BYTE_STRING(isolate, "exports"),
+      FIXED_ONE_BYTE_STRING(isolate, "require"),
+      FIXED_ONE_BYTE_STRING(isolate, "module"),
+      FIXED_ONE_BYTE_STRING(isolate, "__filename"),
+      FIXED_ONE_BYTE_STRING(isolate, "__dirname"),
+  };
+  MaybeLocal<Function> maybe_fn = ScriptCompiler::CompileFunction(
+      context,
+      &source,
+      params.size(),
+      params.data(),
+      0,       /* context extensions size */
+      nullptr, /* context extensions data */
+      // TODO(joyeecheung): allow optional eager compilation.
+      cached_data == nullptr ? ScriptCompiler::kNoCompileOptions
+                             : ScriptCompiler::kConsumeCodeCache,
+      v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
+
+  Local<Function> fn;
+  if (!maybe_fn.ToLocal(&fn)) {
+    if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
+      errors::DecorateErrorStack(env, try_catch);
+      if (!try_catch.HasTerminated()) {
+        try_catch.ReThrow();
+      }
+      return;
+    }
+  }
+
+  bool cache_rejected = false;
+#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
+  if (used_cache_from_sea) {
+    cache_rejected = source.GetCachedData()->rejected;
+  }
+#endif
+
+  std::vector<Local<Name>> names = {
+      env->cached_data_rejected_string(),
+      env->source_map_url_string(),
+      env->function_string(),
+  };
+  std::vector<Local<Value>> values = {
+      Boolean::New(isolate, cache_rejected),
+      fn->GetScriptOrigin().SourceMapUrl(),
+      fn,
+  };
+  Local<Object> result = Object::New(
+      isolate, v8::Null(isolate), names.data(), values.data(), names.size());
+  args.GetReturnValue().Set(result);
+}
+
 static void StartSigintWatchdog(const FunctionCallbackInfo<Value>& args) {
   int ret = SigintWatchdogHelper::GetInstance()->Start();
   args.GetReturnValue().Set(ret == 0);
@@ -1537,6 +1634,10 @@ void CreatePerIsolateProperties(IsolateData* isolate_data,
       isolate, target, "watchdogHasPendingSigint", WatchdogHasPendingSigint);
 
   SetMethod(isolate, target, "measureMemory", MeasureMemory);
+  SetMethod(isolate,
+            target,
+            "compileFunctionForCJSLoader",
+            CompileFunctionForCJSLoader);
 }
 
 static void CreatePerContextProperties(Local<Object> target,
@@ -1576,6 +1677,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   ContextifyContext::RegisterExternalReferences(registry);
   ContextifyScript::RegisterExternalReferences(registry);
 
+  registry->Register(CompileFunctionForCJSLoader);
   registry->Register(StartSigintWatchdog);
   registry->Register(StopSigintWatchdog);
   registry->Register(WatchdogHasPendingSigint);
diff --git a/src/node_contextify.h b/src/node_contextify.h
@@ -94,8 +94,6 @@ class ContextifyContext : public BaseObject {
       bool produce_cached_data,
       v8::Local<v8::Symbol> id_symbol,
       const errors::TryCatchScope& try_catch);
-  static v8::Local<v8::PrimitiveArray> GetHostDefinedOptions(
-      v8::Isolate* isolate, v8::Local<v8::Symbol> id_symbol);
   static v8::ScriptCompiler::Source GetCommonJSSourceInstance(
       v8::Isolate* isolate,
       v8::Local<v8::String> code,
diff --git a/src/node_sea.cc b/src/node_sea.cc
@@ -31,7 +31,6 @@ using node::ExitCode;
 using v8::ArrayBuffer;
 using v8::BackingStore;
 using v8::Context;
-using v8::DataView;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
@@ -219,6 +218,10 @@ bool SeaResource::use_snapshot() const {
   return static_cast<bool>(flags & SeaFlags::kUseSnapshot);
 }
 
+bool SeaResource::use_code_cache() const {
+  return static_cast<bool>(flags & SeaFlags::kUseCodeCache);
+}
+
 SeaResource FindSingleExecutableResource() {
   static const SeaResource sea_resource = []() -> SeaResource {
     std::string_view blob = FindSingleExecutableBlob();
@@ -258,35 +261,6 @@ void IsExperimentalSeaWarningNeeded(const FunctionCallbackInfo<Value>& args) {
       sea_resource.flags & SeaFlags::kDisableExperimentalSeaWarning));
 }
 
-void GetCodeCache(const FunctionCallbackInfo<Value>& args) {
-  if (!IsSingleExecutable()) {
-    return;
-  }
-
-  Isolate* isolate = args.GetIsolate();
-
-  SeaResource sea_resource = FindSingleExecutableResource();
-
-  if (!static_cast<bool>(sea_resource.flags & SeaFlags::kUseCodeCache)) {
-    return;
-  }
-
-  std::shared_ptr<BackingStore> backing_store = ArrayBuffer::NewBackingStore(
-      const_cast<void*>(
-          static_cast<const void*>(sea_resource.code_cache->data())),
-      sea_resource.code_cache->length(),
-      [](void* /* data */, size_t /* length */, void* /* deleter_data */) {
-        // The code cache data blob is not freed here because it is a static
-        // blob which is not allocated by the BackingStore allocator.
-      },
-      nullptr);
-  Local<ArrayBuffer> array_buffer = ArrayBuffer::New(isolate, backing_store);
-  Local<DataView> data_view =
-      DataView::New(array_buffer, 0, array_buffer->ByteLength());
-
-  args.GetReturnValue().Set(data_view);
-}
-
 void GetCodePath(const FunctionCallbackInfo<Value>& args) {
   DCHECK(IsSingleExecutable());
 
@@ -653,15 +627,13 @@ void Initialize(Local<Object> target,
             "isExperimentalSeaWarningNeeded",
             IsExperimentalSeaWarningNeeded);
   SetMethod(context, target, "getCodePath", GetCodePath);
-  SetMethod(context, target, "getCodeCache", GetCodeCache);
   SetMethod(context, target, "getAsset", GetAsset);
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(IsSea);
   registry->Register(IsExperimentalSeaWarningNeeded);
   registry->Register(GetCodePath);
-  registry->Register(GetCodeCache);
   registry->Register(GetAsset);
 }
 
diff --git a/src/node_sea.h b/src/node_sea.h
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "node_exit_code.h"
+#include "v8-script.h"
 
 namespace node {
 namespace sea {
@@ -37,9 +38,12 @@ struct SeaResource {
   std::unordered_map<std::string_view, std::string_view> assets;
 
   bool use_snapshot() const;
+  bool use_code_cache() const;
+
   static constexpr size_t kHeaderSize = sizeof(kMagic) + sizeof(SeaFlags);
 };
 
+std::unique_ptr<v8::ScriptCompiler::CachedData> GetCodeCache();
 bool IsSingleExecutable();
 SeaResource FindSingleExecutableResource();
 std::tuple<int, char**> FixupArgsForSEA(int argc, char** argv);
