src: build v8 tick processor as built-in source text modules

Instead of polyfilling it with vm.SourceTextModule,
use a built-in source text module loader so that we can
also build the code cache for it at build tiem to
embed the code cache for them in the binary.

Drive-by: instead of inferring how to compile a particular
built-in at run time, do the inferring at build time,
so the function-based built-ins can be compiled using
parameters quickly looked up from a static map, and
the builtins that should be compiled as source text
modules are known internally based on extension in
the source code (at run time, the extensions are all
removed).

Author: joyeecheung

lib/internal/main/prof_process.js

@@ -1,10 +1,28 @@
 'use strict';
 
+// TODO(joyeecheung): put the context locals in import.meta.
+const {
+  ObjectAssign,
+  globalThis,
+} = primordials;
+
 const {
   prepareMainThreadExecution,
   markBootstrapComplete,
 } = require('internal/process/pre_execution');
 
+const { importBuiltinSourceTextModule } = internalBinding('builtins');
+
 prepareMainThreadExecution();
 markBootstrapComplete();
-require('internal/v8_prof_processor');
+
+const { globals, openFile } = require('internal/v8_prof_polyfill');
+ObjectAssign(globalThis, globals);
+openFile(process.argv[process.argv.length - 1]);
+
+(async () => {
+  const {
+    promise,
+  } = importBuiltinSourceTextModule('internal/deps/v8/tools/tickprocessor-driver');
+  await promise;
+})();

lib/internal/v8_prof_polyfill.js

@@ -30,17 +30,17 @@
 /* eslint-disable node-core/prefer-primordials, no-restricted-globals */
 /* global console */
 
-module.exports = { versionCheck };
+const {
+  ArrayPrototypePush,
+  ArrayPrototypePushApply,
+  ArrayPrototypeSlice,
+} = primordials;
 
-// Don't execute when required directly instead of being eval'd from
-// lib/internal/v8_prof_processor.js.  This way we can test functions
-// from this file in isolation.
-if (module.id === 'internal/v8_prof_polyfill') return;
-
-// Node polyfill
 const fs = require('fs');
 const cp = require('child_process');
 const { Buffer } = require('buffer');
+const { StringDecoder } = require('string_decoder');
+
 const os = {
   system: function(name, args) {
     if (process.platform === 'linux' && name === 'nm') {
@@ -68,24 +68,40 @@ const os = {
   },
 };
 const print = console.log;
+
 function read(fileName) {
   return fs.readFileSync(fileName, 'utf8');
 }
 const quit = process.exit;
-// Polyfill "readline()".
-const logFile = globalThis.arguments[globalThis.arguments.length - 1];
-try {
-  fs.accessSync(logFile);
-} catch {
-  console.error('Please provide a valid isolate file as the final argument.');
-  process.exit(1);
+
+const tickArguments = [];
+if (process.platform === 'darwin') {
+  ArrayPrototypePush(tickArguments, '--mac');
+} else if (process.platform === 'win32') {
+  ArrayPrototypePush(tickArguments, '--windows');
 }
-const fd = fs.openSync(logFile, 'r');
+ArrayPrototypePushApply(tickArguments,
+                        ArrayPrototypeSlice(process.argv, 1));
+
+function write(str) { process.stdout.write(str); };
+function printErr(str) { process.stderr.write(str); };
+
+let logFile;
+let fd;
 const buf = Buffer.allocUnsafe(4096);
-const dec = new (require('string_decoder').StringDecoder)('utf-8');
+const dec = new StringDecoder('utf-8');
 let line = '';
 
-{
+function openFile(filename) {
+  logFile = filename;
+  try {
+    fd = fs.openSync(logFile, 'r');
+  } catch (e) {
+    console.error(`Cannot access log file: ${logFile}`);
+    console.error('Please provide a valid isolate file as the final argument.');
+    throw e;
+  }
+
   const message = versionCheck(peekline(), process.versions.v8);
   if (message) console.log(message);
 }
@@ -162,10 +178,17 @@ function macCppfiltNm(out) {
   });
 }
 
-Object.assign(globalThis, {
-  os,
-  print,
-  read,
-  quit,
-  readline,
-});
+module.exports = {
+  globals: {
+    arguments: tickArguments,
+    write,
+    printErr,
+    os,
+    print,
+    read,
+    quit,
+    readline,
+  },
+  openFile,
+  versionCheck,
+};

lib/internal/v8_prof_processor.js

@@ -73,6 +73,7 @@
       'src/async_context_frame.cc',
       'src/async_wrap.cc',
       'src/base_object.cc',
+      'src/builtin_info.cc',
       'src/cares_wrap.cc',
       'src/cleanup_queue.cc',
       'src/compile_cache.cc',
@@ -214,6 +215,7 @@
       'src/base_object_types.h',
       'src/blob_serializer_deserializer.h',
       'src/blob_serializer_deserializer-inl.h',
+      "src/builtin_info.h",
       'src/callback_queue.h',
       'src/callback_queue-inl.h',
       'src/cleanup_queue.h',
@@ -1381,6 +1383,8 @@
         'tools/executable_wrapper.h',
         'src/embedded_data.h',
         'src/embedded_data.cc',
+        'src/builtin_info.h',
+        'src/builtin_info.cc',
       ],
       'conditions': [
         [ 'node_shared_simdutf=="false"', {

node.gyp

@@ -914,7 +914,7 @@ Maybe<void> InitializePrimordials(Local<Context> context,
         exports, primordials, private_symbols, per_isolate_symbols};
 
     if (builtin_loader
-            .CompileAndCall(
+            .CompileAndCallWith(
                 context, *module, arraysize(arguments), arguments, nullptr)
             .IsEmpty()) {
       // Execution failed during context creation.

src/api/environment.cc

@@ -0,0 +1,48 @@
+#include "builtin_info.h"
+
+namespace node {
+namespace builtins {
+
+BuiltinSourceType GetBuiltinSourceType(const std::string& id,
+                                       const std::string& filename) {
+  if (filename.ends_with(".mjs")) {
+    return BuiltinSourceType::kSourceTextModule;
+  }
+  if (id.starts_with("internal/bootstrap/realm")) {
+    return BuiltinSourceType::kBootstrapRealm;
+  }
+  if (id.starts_with("internal/bootstrap/")) {
+    return BuiltinSourceType::kBootstrapScript;
+  }
+  if (id.starts_with("internal/per_context/")) {
+    return BuiltinSourceType::kPerContextScript;
+  }
+  if (id.starts_with("internal/main/")) {
+    return BuiltinSourceType::kMainScript;
+  }
+  if (id.starts_with("internal/deps/v8/tools/")) {
+    return BuiltinSourceType::kSourceTextModule;
+  }
+  return BuiltinSourceType::kFunction;
+}
+
+std::string GetBuiltinSourceTypeName(BuiltinSourceType type) {
+  switch (type) {
+    case BuiltinSourceType::kBootstrapRealm:
+      return "kBootstrapRealm";
+    case BuiltinSourceType::kBootstrapScript:
+      return "kBootstrapScript";
+    case BuiltinSourceType::kPerContextScript:
+      return "kPerContextScript";
+    case BuiltinSourceType::kMainScript:
+      return "kMainScript";
+    case BuiltinSourceType::kFunction:
+      return "kFunction";
+    case BuiltinSourceType::kSourceTextModule:
+      return "kSourceTextModule";
+  }
+  abort();
+}
+
+}  // namespace builtins
+}  // namespace node

src/builtin_info.cc

@@ -0,0 +1,57 @@
+#ifndef SRC_BUILTIN_INFO_H_
+#define SRC_BUILTIN_INFO_H_
+
+#include <cinttypes>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+// This file must not depend on node.h or other code that depends on
+// the full Node.js implementation because it is used during the
+// compilation of the Node.js implementation itself (especially js2c).
+
+namespace node {
+namespace builtins {
+
+enum class BuiltinSourceType {
+  kBootstrapRealm,    // internal/bootstrap/realm
+  kBootstrapScript,   // internal/bootstrap/*
+  kPerContextScript,  // internal/per_context/*
+  kMainScript,        // internal/main/*
+  kFunction,          // others
+  kSourceTextModule,  // selected modules, ends with .mjs in source
+};
+
+struct BuiltinInfo {
+  // C++17 inline static
+  inline static const std::unordered_map<BuiltinSourceType,
+                                         std::vector<std::string>>
+      parameter_map{
+          {BuiltinSourceType::kBootstrapRealm,
+           {"process",
+            "getLinkedBinding",
+            "getInternalBinding",
+            "primordials"}},
+          {BuiltinSourceType::kBootstrapScript,
+           {"process", "require", "internalBinding", "primordials"}},
+          {BuiltinSourceType::kPerContextScript,
+           {"exports", "primordials", "privateSymbols", "perIsolateSymbols"}},
+          {BuiltinSourceType::kMainScript,
+           {"process", "require", "internalBinding", "primordials"}},
+          {BuiltinSourceType::kFunction,
+           {"exports",
+            "require",
+            "module",
+            "process",
+            "internalBinding",
+            "primordials"}},
+      };
+};
+
+std::string GetBuiltinSourceTypeName(BuiltinSourceType type);
+BuiltinSourceType GetBuiltinSourceType(const std::string& id,
+                                       const std::string& filename);
+}  // namespace builtins
+}  // namespace node
+
+#endif  // SRC_BUILTIN_INFO_H_

src/builtin_info.h

@@ -57,6 +57,7 @@
   V(onpskexchange_symbol, "onpskexchange")                                     \
   V(resource_symbol, "resource_symbol")                                        \
   V(trigger_async_id_symbol, "trigger_async_id_symbol")                        \
+  V(builtin_source_text_module_hdo, "builtin_source_text_module_hdo")          \
   V(source_text_module_default_hdo, "source_text_module_default_hdo")          \
   V(vm_context_no_contextify, "vm_context_no_contextify")                      \
   V(vm_dynamic_import_default_internal, "vm_dynamic_import_default_internal")  \