src: use STL containers instead of v8 values for static module data

Instead of putting the source code and the cache in v8::Objects,
put them in per-process std::maps. This has the following benefits:

- It's slightly lighter in weight compared to storing things on the
  v8 heap. Also it may be slightly faster since the preivous v8::Object
  is already in dictionary mode - though the difference is very small
  given the number of native modules is limited.
- The source and code cache generation templates are now much simpler
  since they just initialize static arrays and manipulate STL
  constructs.
- The static native module data can be accessed independently of any
  Environment or Isolate, and it's easy to look them up from the
  C++'s side.
- It's now impossible to mutate the source code used to compile
  native modules from the JS land since it's completely separate
  from the v8 heap. We can still get the constant strings from
  process.binding('natives') but that's all.

A few drive-by fixes:

- Remove DecorateErrorStack in LookupAndCompile - We don't need to
  capture the exception to decorate when we encounter
  errors during native module compilation, as those errors should be
  syntax errors and v8 is able to decorate them well. We use
  CompileFunctionInContext so there is no need to worry about
  wrappers either.
- The code cache could be rejected when node is started with v8 flags.
  Instead of aborting in that case, simply keep a record in the
  native_module_without_cache set.
- Refactor js2c.py a bit, reduce code duplication and inline Render()
  to make the one-byte/two-byte special treatment easier to read.

PR-URL: nodejs#24384
Fixes: https://github.com/Remove
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: joyeecheung

lib/internal/bootstrap/cache.js

@@ -9,11 +9,12 @@ const {
   NativeModule
 } = require('internal/bootstrap/loaders');
 const {
-  source,
+  getSource,
   compileCodeCache
 } = internalBinding('native_module');
 const { hasTracing } = process.binding('config');
 
+const source = getSource();
 const depsModule = Object.keys(source).filter(
   (key) => NativeModule.isDepsModule(key) || key.startsWith('internal/deps')
 );

node.gyp

@@ -410,15 +410,13 @@
         'src/node_api.h',
         'src/node_api_types.h',
         'src/node_buffer.h',
-        'src/node_code_cache.h',
         'src/node_constants.h',
         'src/node_contextify.h',
         'src/node_errors.h',
         'src/node_file.h',
         'src/node_http2.h',
         'src/node_http2_state.h',
         'src/node_internals.h',
-        'src/node_javascript.h',
         'src/node_messaging.h',
         'src/node_mutex.h',
         'src/node_native_module.h',
@@ -430,6 +428,7 @@
         'src/node_persistent.h',
         'src/node_platform.h',
         'src/node_root_certs.h',
+        'src/node_union_bytes.h',
         'src/node_version.h',
         'src/node_watchdog.h',
         'src/node_revert.h',

src/env.cc

@@ -1,13 +1,14 @@
-#include "node_internals.h"
 #include "async_wrap.h"
-#include "v8-profiler.h"
 #include "node_buffer.h"
-#include "node_platform.h"
-#include "node_file.h"
 #include "node_context_data.h"
+#include "node_file.h"
+#include "node_internals.h"
+#include "node_native_module.h"
+#include "node_platform.h"
 #include "node_worker.h"
 #include "tracing/agent.h"
 #include "tracing/traced_value.h"
+#include "v8-profiler.h"
 
 #include <stdio.h>
 #include <algorithm>

src/env.h

@@ -29,13 +29,13 @@
 #include "inspector_agent.h"
 #endif
 #include "handle_wrap.h"
+#include "node.h"
+#include "node_http2_state.h"
+#include "node_options.h"
 #include "req_wrap.h"
 #include "util.h"
 #include "uv.h"
 #include "v8.h"
-#include "node.h"
-#include "node_options.h"
-#include "node_http2_state.h"
 
 #include <list>
 #include <stdint.h>
@@ -347,12 +347,6 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
   V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                     \
   V(message_port, v8::Object)                                                  \
   V(message_port_constructor_template, v8::FunctionTemplate)                   \
-  V(native_modules_code_cache, v8::Object)                                     \
-  V(native_modules_code_cache_hash, v8::Object)                                \
-  V(native_modules_source, v8::Object)                                         \
-  V(native_modules_source_hash, v8::Object)                                    \
-  V(native_modules_with_cache, v8::Set)                                        \
-  V(native_modules_without_cache, v8::Set)                                     \
   V(performance_entry_callback, v8::Function)                                  \
   V(performance_entry_template, v8::Function)                                  \
   V(pipe_constructor_template, v8::FunctionTemplate)                           \
@@ -684,6 +678,9 @@ class Environment {
   // List of id's that have been destroyed and need the destroy() cb called.
   inline std::vector<double>* destroy_async_id_list();
 
+  std::set<std::string> native_modules_with_cache;
+  std::set<std::string> native_modules_without_cache;
+
   std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
   std::unordered_map<uint32_t, loader::ModuleWrap*> id_to_module_map;
   std::unordered_map<uint32_t, contextify::ContextifyScript*>

src/node.cc

@@ -24,7 +24,6 @@
 #include "node_context_data.h"
 #include "node_errors.h"
 #include "node_internals.h"
-#include "node_javascript.h"
 #include "node_native_module.h"
 #include "node_perf.h"
 #include "node_platform.h"
@@ -130,7 +129,7 @@ typedef int mode_t;
 
 namespace node {
 
-using native_module::NativeModule;
+using native_module::NativeModuleLoader;
 using options_parser::kAllowedInEnvironment;
 using options_parser::kDisallowedInEnvironment;
 using v8::Array;
@@ -212,7 +211,7 @@ double prog_start_time;
 Mutex per_process_opts_mutex;
 std::shared_ptr<PerProcessOptions> per_process_opts {
     new PerProcessOptions() };
-
+NativeModuleLoader per_process_loader;
 static Mutex node_isolate_mutex;
 static Isolate* node_isolate;
 
@@ -1243,8 +1242,7 @@ static void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
                                 Null(env->isolate())).FromJust());
     DefineConstants(env->isolate(), exports);
   } else if (!strcmp(*module_v, "natives")) {
-    exports = Object::New(env->isolate());
-    NativeModule::GetNatives(env, exports);
+    exports = per_process_loader.GetSourceObject(env->context());
   } else {
     return ThrowIfNoSuchModule(env, *module_v);
   }
@@ -1780,18 +1778,24 @@ void LoadEnvironment(Environment* env) {
 
   // The bootstrapper scripts are lib/internal/bootstrap/loaders.js and
   // lib/internal/bootstrap/node.js, each included as a static C string
-  // defined in node_javascript.h, generated in node_javascript.cc by
-  // node_js2c.
+  // generated in node_javascript.cc by node_js2c.
 
-  // TODO(joyeecheung): use NativeModule::Compile
+  // TODO(joyeecheung): use NativeModuleLoader::Compile
+  // We duplicate the string literals here since once we refactor the bootstrap
+  // compilation out to NativeModuleLoader none of this is going to matter
+  Isolate* isolate = env->isolate();
   Local<String> loaders_name =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/loaders.js");
+      FIXED_ONE_BYTE_STRING(isolate, "internal/bootstrap/loaders.js");
+  Local<String> loaders_source =
+      per_process_loader.GetSource(isolate, "internal/bootstrap/loaders");
   MaybeLocal<Function> loaders_bootstrapper =
-      GetBootstrapper(env, LoadersBootstrapperSource(env), loaders_name);
+      GetBootstrapper(env, loaders_source, loaders_name);
   Local<String> node_name =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/node.js");
+      FIXED_ONE_BYTE_STRING(isolate, "internal/bootstrap/node.js");
+  Local<String> node_source =
+      per_process_loader.GetSource(isolate, "internal/bootstrap/node");
   MaybeLocal<Function> node_bootstrapper =
-      GetBootstrapper(env, NodeBootstrapperSource(env), node_name);
+      GetBootstrapper(env, node_source, node_name);
 
   if (loaders_bootstrapper.IsEmpty() || node_bootstrapper.IsEmpty()) {
     // Execution was interrupted.
@@ -1843,8 +1847,6 @@ void LoadEnvironment(Environment* env) {
                  env->options()->debug_options->break_node_first_line)
   };
 
-  NativeModule::LoadBindings(env);
-
   // Bootstrap internal loaders
   Local<Value> bootstrapped_loaders;
   if (!ExecuteBootstrapper(env, loaders_bootstrapper.ToLocalChecked(),
@@ -2485,7 +2487,6 @@ void FreePlatform(MultiIsolatePlatform* platform) {
   delete platform;
 }
 
-
 Local<Context> NewContext(Isolate* isolate,
                           Local<ObjectTemplate> object_template) {
   auto context = Context::New(isolate, nullptr, object_template);
@@ -2499,8 +2500,9 @@ Local<Context> NewContext(Isolate* isolate,
     // Run lib/internal/per_context.js
     Context::Scope context_scope(context);
 
-    // TODO(joyeecheung): use NativeModule::Compile
-    Local<String> per_context = NodePerContextSource(isolate);
+    // TODO(joyeecheung): use NativeModuleLoader::Compile
+    Local<String> per_context =
+        per_process_loader.GetSource(isolate, "internal/per_context");
     ScriptCompiler::Source per_context_src(per_context, nullptr);
     Local<Script> s = ScriptCompiler::Compile(
         context,

src/node_code_cache.h

@@ -1,23 +1,19 @@
 
-#include "node_code_cache.h"
+#include "node_native_module.h"
 
 // This is supposed to be generated by tools/generate_code_cache.js
 // The stub here is used when configure is run without `--code-cache-path`
 
 namespace node {
+namespace native_module {
 
-const bool native_module_has_code_cache = false;
+// The generated source code would insert <std::string, UnionString> pairs
+// into native_module_loader.code_cache_.
+void NativeModuleLoader::LoadCodeCache() {}
 
-void DefineCodeCache(Environment* env, v8::Local<v8::Object> target) {
-  // When we do not produce code cache for builtin modules,
-  // `internalBinding('code_cache')` returns an empty object
-  // (here as `target`) so this is a noop.
-}
-
-void DefineCodeCacheHash(Environment* env, v8::Local<v8::Object> target) {
-  // When we do not produce code cache for builtin modules,
-  // `internalBinding('code_cache_hash')` returns an empty object
-  // (here as `target`) so this is a noop.
-}
+// The generated source code would instert <std::string, std::string> pairs
+// into native_module_loader.code_cache_hash_.
+void NativeModuleLoader::LoadCodeCacheHash() {}
 
+}  // namespace native_module
 }  // namespace node

src/node_code_cache_stub.cc

@@ -171,6 +171,10 @@ struct sockaddr;
 
 namespace node {
 
+namespace native_module {
+class NativeModuleLoader;
+}
+
 extern Mutex process_mutex;
 extern Mutex environ_mutex;
 
@@ -179,6 +183,7 @@ extern bool v8_initialized;
 
 extern Mutex per_process_opts_mutex;
 extern std::shared_ptr<PerProcessOptions> per_process_opts;
+extern native_module::NativeModuleLoader per_process_loader;
 
 // Forward declaration
 class Environment;

src/node_internals.h

@@ -3,34 +3,68 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "node_internals.h"
+#include <map>
+#include <set>
+#include <string>
+#include "env.h"
+#include "node_union_bytes.h"
+#include "v8.h"
 
 namespace node {
 namespace native_module {
 
-// The native (C++) side of the native module compilation.
+using NativeModuleRecordMap = std::map<std::string, UnionBytes>;
+using NativeModuleHashMap = std::map<std::string, std::string>;
 
-class NativeModule {
+// The native (C++) side of the native module compilation.
+// This class should not depend on Environment
+class NativeModuleLoader {
  public:
-  // For legacy process.binding('natives') which is mutable
-  static void GetNatives(Environment* env, v8::Local<v8::Object> exports);
-  // Loads the static JavaScript source code and the cache into Environment
-  static void LoadBindings(Environment* env);
+  NativeModuleLoader();
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context);
+  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context) const;
+  v8::Local<v8::String> GetSource(v8::Isolate* isolate, const char* id) const;
+
+ private:
+  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // For legacy process.binding('natives') which is mutable, and for
+  // internalBinding('native_module').source for internal use
+  static void GetSourceObject(const v8::FunctionCallbackInfo<v8::Value>& args);
   // Compile code cache for a specific native module
   static void CompileCodeCache(const v8::FunctionCallbackInfo<v8::Value>& args);
   // Compile a specific native module as a function
   static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
 
- private:
+  // Generated by tools/js2c.py as node_javascript.cc
+  void LoadJavaScriptSource();  // Loads data into source_
+  void LoadJavaScriptHash();    // Loads data into source_hash_
+
+  // Generated by tools/generate_code_cache.js as node_code_cache.cc when
+  // the build is configured with --code-cache-path=.... They are noops
+  // in node_code_cache_stub.cc
+  void LoadCodeCache();      // Loads data into code_cache_
+  void LoadCodeCacheHash();  // Loads data into code_cache_hash_
+
+  v8::ScriptCompiler::CachedData* GetCachedData(const char* id) const;
   static v8::Local<v8::Value> CompileAsModule(Environment* env,
-                                              v8::Local<v8::String> id,
+                                              const char* id,
                                               bool produce_code_cache);
-  // TODO(joyeecheung): make this public and reuse it to compile bootstrappers
-  static v8::Local<v8::Value> Compile(Environment* env,
-                                      v8::Local<v8::String> id,
-                                      v8::Local<v8::String> parameters[],
-                                      size_t parameters_count,
-                                      bool produce_code_cache);
+  // TODO(joyeecheung): make this public and reuse it to compile bootstrappers.
+  // For bootstrappers optional_env may be a nullptr.
+  // This method magically knows what parameter it should pass to
+  // the function to be compiled.
+  v8::Local<v8::Value> LookupAndCompile(v8::Local<v8::Context> context,
+                                        const char* id,
+                                        bool produce_code_cache,
+                                        Environment* optional_env);
+
+  bool has_code_cache_ = false;
+  NativeModuleRecordMap source_;
+  NativeModuleRecordMap code_cache_;
+  NativeModuleHashMap source_hash_;
+  NativeModuleHashMap code_cache_hash_;
 };
 
 }  // namespace native_module

src/node_javascript.h

@@ -0,0 +1,93 @@
+
+#ifndef SRC_NODE_UNION_BYTES_H_
+#define SRC_NODE_UNION_BYTES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// A union of const uint8_t* or const uint16_t* data that can be
+// turned into external v8::String when given an isolate.
+
+#include "env.h"
+#include "v8.h"
+
+namespace node {
+
+class NonOwningExternalOneByteResource
+    : public v8::String::ExternalOneByteStringResource {
+ public:
+  explicit NonOwningExternalOneByteResource(const uint8_t* data, size_t length)
+      : data_(data), length_(length) {}
+  ~NonOwningExternalOneByteResource() override = default;
+
+  const char* data() const override {
+    return reinterpret_cast<const char*>(data_);
+  }
+  size_t length() const override { return length_; }
+
+ private:
+  const uint8_t* data_;
+  size_t length_;
+  DISALLOW_COPY_AND_ASSIGN(NonOwningExternalOneByteResource);
+};
+
+class NonOwningExternalTwoByteResource
+    : public v8::String::ExternalStringResource {
+ public:
+  explicit NonOwningExternalTwoByteResource(const uint16_t* data, size_t length)
+      : data_(data), length_(length) {}
+  ~NonOwningExternalTwoByteResource() override = default;
+
+  const uint16_t* data() const override { return data_; }
+  size_t length() const override { return length_; }
+
+ private:
+  const uint16_t* data_;
+  size_t length_;
+  DISALLOW_COPY_AND_ASSIGN(NonOwningExternalTwoByteResource);
+};
+
+// Similar to a v8::String, but it's independent from Isolates
+// and can be materialized in Isolates as external Strings
+// via ToStringChecked. The data pointers are owned by the caller.
+class UnionBytes {
+ public:
+  UnionBytes(const uint16_t* data, size_t length)
+      : is_one_byte_(false), two_bytes_(data), length_(length) {}
+  UnionBytes(const uint8_t* data, size_t length)
+      : is_one_byte_(true), one_bytes_(data), length_(length) {}
+  bool is_one_byte() const { return is_one_byte_; }
+  const uint16_t* two_bytes_data() const {
+    CHECK(!is_one_byte_);
+    return two_bytes_;
+  }
+  const uint8_t* one_bytes_data() const {
+    CHECK(is_one_byte_);
+    return one_bytes_;
+  }
+  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const {
+    if (is_one_byte_) {
+      NonOwningExternalOneByteResource* source =
+          new NonOwningExternalOneByteResource(one_bytes_, length_);
+      return v8::String::NewExternalOneByte(isolate, source).ToLocalChecked();
+    } else {
+      NonOwningExternalTwoByteResource* source =
+          new NonOwningExternalTwoByteResource(two_bytes_, length_);
+      return v8::String::NewExternalTwoByte(isolate, source).ToLocalChecked();
+    }
+  }
+  size_t length() { return length_; }
+
+ private:
+  bool is_one_byte_;
+  union {
+    const uint8_t* one_bytes_;
+    const uint16_t* two_bytes_;
+  };
+  size_t length_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_UNION_BYTES_H_

src/node_native_module.cc

@@ -30,10 +30,10 @@ if (child.status !== 0) {
 }
 
 // Verifies that:
-// - node::DefineCodeCache()
-// - node::DefineCodeCacheHash()
+// - node::LoadCodeCache()
+// - node::LoadCodeCacheHash()
 // are defined in the generated code.
-// See src/node_code_cache_stub.cc for explanations.
+// See src/node_native_module.h for explanations.
 
 const rl = readline.createInterface({
   input: fs.createReadStream(dest),
@@ -44,10 +44,10 @@ let hasCacheDef = false;
 let hasHashDef = false;
 
 rl.on('line', common.mustCallAtLeast((line) => {
-  if (line.includes('DefineCodeCache(')) {
+  if (line.includes('LoadCodeCache(')) {
     hasCacheDef = true;
   }
-  if (line.includes('DefineCodeCacheHash(')) {
+  if (line.includes('LoadCodeCacheHash(')) {
     hasHashDef = true;
   }
 }, 2));

src/node_native_module.h

@@ -19,8 +19,7 @@ const {
   internalBinding
 } = require('internal/test/binding');
 const {
-  compiledWithoutCache,
-  compiledWithCache
+  getCacheUsage
 } = internalBinding('native_module');
 
 for (const key of cachableBuiltins) {
@@ -30,6 +29,12 @@ for (const key of cachableBuiltins) {
   require(key);
 }
 
+// The computation has to be delayed until we have done loading modules
+const {
+  compiledWithoutCache,
+  compiledWithCache
+} = getCacheUsage();
+
 const loadedModules = process.moduleLoadList
   .filter((m) => m.startsWith('NativeModule'))
   .map((m) => m.replace('NativeModule ', ''));
@@ -39,7 +44,11 @@ const loadedModules = process.moduleLoadList
 if (process.config.variables.node_code_cache_path === undefined) {
   console.log('The binary is not configured with code cache');
   assert.deepStrictEqual(compiledWithCache, new Set());
-  assert.deepStrictEqual(compiledWithoutCache, new Set(loadedModules));
+
+  for (const key of loadedModules) {
+    assert(compiledWithoutCache.has(key),
+           `"${key}" should've been compiled without code cache`);
+  }
 } else {
   console.log('The binary is configured with code cache');
   assert.strictEqual(

src/node_union_bytes.h

@@ -13,6 +13,12 @@ const {
   cachableBuiltins
 } = require('internal/bootstrap/cache');
 
+const {
+  types: {
+    isUint8Array
+  }
+} = require('util');
+
 function hash(str) {
   if (process.versions.openssl) {
     return require('crypto').createHash('sha256').update(str).digest('hex');
@@ -52,29 +58,25 @@ function formatSize(num) {
  * initializers of the code cache.
  *
  * @param {string} key ID of the builtin module
- * @param {Buffer} cache Code cache of the builtin module
+ * @param {Uint8Array} cache Code cache of the builtin module
  * @return { definition: string, initializer: string }
  */
 function getInitalizer(key, cache) {
-  const defName = key.replace(/\//g, '_').replace(/-/g, '_');
-  const definition = `static uint8_t ${defName}_raw[] = {\n` +
+  const defName = `${key.replace(/\//g, '_').replace(/-/g, '_')}_raw`;
+  const definition = `static const uint8_t ${defName}[] = {\n` +
                      `${cache.join(',')}\n};`;
   const source = getSource(key);
   const sourceHash = hash(source);
-  const initializer = `
-  v8::Local<v8::ArrayBuffer> ${defName}_ab =
-    v8::ArrayBuffer::New(isolate, ${defName}_raw, ${cache.length});
-  v8::Local<v8::Uint8Array> ${defName}_array =
-    v8::Uint8Array::New(${defName}_ab, 0, ${cache.length});
-  target->Set(context,
-              FIXED_ONE_BYTE_STRING(isolate, "${key}"),
-              ${defName}_array).FromJust();
-  `;
-  const hashIntializer = `
-  target->Set(context,
-              FIXED_ONE_BYTE_STRING(isolate, "${key}"),
-              OneByteString(isolate, "${sourceHash}")).FromJust();
-  `;
+  const initializer =
+    'code_cache_.emplace(\n' +
+    `  "${key}",\n` +
+    `  UnionBytes(${defName}, arraysize(${defName}))\n` +
+    ');';
+  const hashIntializer =
+    'code_cache_hash_.emplace(\n' +
+    `  "${key}",\n` +
+    `  "${sourceHash}"\n` +
+    ');';
   return {
     definition, initializer, hashIntializer, sourceHash
   };
@@ -85,55 +87,55 @@ const cacheInitializers = [];
 const cacheHashInitializers = [];
 let totalCacheSize = 0;
 
+function lexical(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+}
 
-for (const key of cachableBuiltins) {
+for (const key of cachableBuiltins.sort(lexical)) {
   const cachedData = getCodeCache(key);
-  if (!cachedData.length) {
+  if (!isUint8Array(cachedData)) {
     console.error(`Failed to generate code cache for '${key}'`);
     process.exit(1);
   }
 
-  const length = cachedData.length;
-  totalCacheSize += length;
+  const size = cachedData.byteLength;
+  totalCacheSize += size;
   const {
     definition, initializer, hashIntializer, sourceHash
   } = getInitalizer(key, cachedData);
   cacheDefinitions.push(definition);
   cacheInitializers.push(initializer);
   cacheHashInitializers.push(hashIntializer);
-  console.log(`Generated cache for '${key}', size = ${formatSize(length)}` +
+  console.log(`Generated cache for '${key}', size = ${formatSize(size)}` +
               `, hash = ${sourceHash}, total = ${formatSize(totalCacheSize)}`);
 }
 
-const result = `#include "node.h"
-#include "node_code_cache.h"
-#include "v8.h"
-#include "env.h"
-#include "env-inl.h"
+const result = `#include "node_native_module.h"
+#include "node_internals.h"
 
 // This file is generated by tools/generate_code_cache.js
 // and is used when configure is run with \`--code-cache-path\`
 
 namespace node {
-
+namespace native_module {
 ${cacheDefinitions.join('\n\n')}
 
-const bool native_module_has_code_cache = true;
-
-// The target here will be returned as \`internalBinding('code_cache')\`
-void DefineCodeCache(Environment* env, v8::Local<v8::Object> target) {
-  v8::Isolate* isolate = env->isolate();
-  v8::Local<v8::Context> context = env->context();
-  ${cacheInitializers.join('\n')}
+void NativeModuleLoader::LoadCodeCache() {
+  has_code_cache_ = true;
+  ${cacheInitializers.join('\n  ')}
 }
 
-// The target here will be returned as \`internalBinding('code_cache_hash')\`
-void DefineCodeCacheHash(Environment* env, v8::Local<v8::Object> target) {
-  v8::Isolate* isolate = env->isolate();
-  v8::Local<v8::Context> context = env->context();
-  ${cacheHashInitializers.join('\n')}
+void NativeModuleLoader::LoadCodeCacheHash() {
+  ${cacheHashInitializers.join('\n  ')}
 }
 
+}  // namespace native_module
 }  // namespace node
 `;
 

test/code-cache/test-code-cache-generator.js

@@ -43,11 +43,6 @@ def ToCArray(elements, step=10):
   slices = map(lambda s: ','.join(str(x) for x in s), slices)
   return ',\n'.join(slices)
 
-
-def ToCString(contents):
-  return ToCArray(map(ord, contents), step=20)
-
-
 def ReadFile(filename):
   file = open(filename, "rt")
   try:
@@ -176,79 +171,49 @@ def ReadMacros(lines):
 
 
 TEMPLATE = """
-#include "node.h"
-#include "node_javascript.h"
-#include "v8.h"
-#include "env.h"
-#include "env-inl.h"
+#include "node_native_module.h"
+#include "node_internals.h"
 
 namespace node {{
 
-namespace {{
+namespace native_module {{
 
 {definitions}
 
-}}  // anonymous namespace
-
-v8::Local<v8::String> NodePerContextSource(v8::Isolate* isolate) {{
-  return internal_per_context_value.ToStringChecked(isolate);
-}}
-
-v8::Local<v8::String> LoadersBootstrapperSource(Environment* env) {{
-  return internal_bootstrap_loaders_value.ToStringChecked(env->isolate());
-}}
-
-v8::Local<v8::String> NodeBootstrapperSource(Environment* env) {{
-  return internal_bootstrap_node_value.ToStringChecked(env->isolate());
-}}
-
-void DefineJavaScript(Environment* env, v8::Local<v8::Object> target) {{
+void NativeModuleLoader::LoadJavaScriptSource() {{
   {initializers}
 }}
 
-void DefineJavaScriptHash(Environment* env, v8::Local<v8::Object> target) {{
+void NativeModuleLoader::LoadJavaScriptHash() {{
   {hash_initializers}
 }}
 
+}}  // namespace native_module
+
 }}  // namespace node
 """
 
 ONE_BYTE_STRING = """
-static const uint8_t raw_{var}[] = {{ {data} }};
-static struct : public v8::String::ExternalOneByteStringResource {{
-  const char* data() const override {{
-    return reinterpret_cast<const char*>(raw_{var});
-  }}
-  size_t length() const override {{ return arraysize(raw_{var}); }}
-  void Dispose() override {{ /* Default calls `delete this`. */ }}
-  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) {{
-    return v8::String::NewExternalOneByte(isolate, this).ToLocalChecked();
-  }}
-}} {var};
+static const uint8_t {var}[] = {{ {data} }};
 """
 
 TWO_BYTE_STRING = """
-static const uint16_t raw_{var}[] = {{ {data} }};
-static struct : public v8::String::ExternalStringResource {{
-  const uint16_t* data() const override {{ return raw_{var}; }}
-  size_t length() const override {{ return arraysize(raw_{var}); }}
-  void Dispose() override {{ /* Default calls `delete this`. */ }}
-  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) {{
-    return v8::String::NewExternalTwoByte(isolate, this).ToLocalChecked();
-  }}
-}} {var};
+static const uint16_t {var}[] = {{ {data} }};
 """
 
-INITIALIZER = """\
-CHECK(target->Set(env->context(),
-                  {key}.ToStringChecked(env->isolate()),
-                  {value}.ToStringChecked(env->isolate())).FromJust());
+
+INITIALIZER = """
+source_.emplace(
+    "{module}",
+    UnionBytes({var}, arraysize({var}))
+);
 """
 
 HASH_INITIALIZER = """\
-CHECK(target->Set(env->context(),
-                  FIXED_ONE_BYTE_STRING(env->isolate(), "{key}"),
-                  FIXED_ONE_BYTE_STRING(env->isolate(), "{value}")).FromJust());
+source_hash_.emplace(
+    "{module}",
+    "{hash_value}"
+);
 """
 
 DEPRECATED_DEPS = """\
@@ -259,20 +224,6 @@ def ReadMacros(lines):
 module.exports = require('internal/deps/{module}');
 """
 
-
-def Render(var, data):
-  # Treat non-ASCII as UTF-8 and convert it to UTF-16.
-  if any(ord(c) > 127 for c in data):
-    template = TWO_BYTE_STRING
-    data = map(ord, data.decode('utf-8').encode('utf-16be'))
-    data = [data[i] * 256 + data[i+1] for i in xrange(0, len(data), 2)]
-    data = ToCArray(data)
-  else:
-    template = ONE_BYTE_STRING
-    data = ToCString(data)
-  return template.format(var=var, data=data)
-
-
 def JS2C(source, target):
   modules = []
   consts = {}
@@ -291,7 +242,29 @@ def JS2C(source, target):
   # Build source code lines
   definitions = []
   initializers = []
-  hash_initializers = [];
+  hash_initializers = []
+
+  def AddModule(module, source):
+    var = '%s_raw' % (module.replace('-', '_').replace('/', '_'))
+    source_hash = hashlib.sha256(source).hexdigest()
+
+    # Treat non-ASCII as UTF-8 and convert it to UTF-16.
+    if any(ord(c) > 127 for c in source):
+      source = map(ord, source.decode('utf-8').encode('utf-16be'))
+      source = [source[i] * 256 + source[i+1] for i in xrange(0, len(source), 2)]
+      source = ToCArray(source)
+      definition = TWO_BYTE_STRING.format(var=var, data=source)
+    else:
+      source = ToCArray(map(ord, source), step=20)
+      definition = ONE_BYTE_STRING.format(var=var, data=source)
+
+    initializer = INITIALIZER.format(module=module,
+                                     var=var)
+    hash_initializer = HASH_INITIALIZER.format(module=module,
+                                               hash_value=source_hash)
+    definitions.append(definition)
+    initializers.append(initializer)
+    hash_initializers.append(hash_initializer)
 
   for name in modules:
     lines = ReadFile(str(name))
@@ -317,28 +290,14 @@ def JS2C(source, target):
     if name.endswith(".gypi"):
       lines = re.sub(r'#.*?\n', '', lines)
       lines = re.sub(r'\'', '"', lines)
-    name = name.split('.', 1)[0]
-    var = name.replace('-', '_').replace('/', '_')
-    key = '%s_key' % var
-    value = '%s_value' % var
-    hash_value = hashlib.sha256(lines).hexdigest()
 
-    definitions.append(Render(key, name))
-    definitions.append(Render(value, lines))
-    initializers.append(INITIALIZER.format(key=key, value=value))
-    hash_initializers.append(HASH_INITIALIZER.format(key=name, value=hash_value))
+    AddModule(name.split('.', 1)[0], lines)
 
+    # Add deprecated aliases for deps without 'deps/'
     if deprecated_deps is not None:
-      name = '/'.join(deprecated_deps)
-      name = name.split('.', 1)[0]
-      var = name.replace('-', '_').replace('/', '_')
-      key = '%s_key' % var
-      value = '%s_value' % var
-
-      definitions.append(Render(key, name))
-      definitions.append(Render(value, DEPRECATED_DEPS.format(module=name)))
-      initializers.append(INITIALIZER.format(key=key, value=value))
-      hash_initializers.append(HASH_INITIALIZER.format(key=name, value=hash_value))
+      module = '/'.join(deprecated_deps).split('.', 1)[0]
+      source = DEPRECATED_DEPS.format(module=module)
+      AddModule(module, source)
 
   # Emit result
   output = open(str(target[0]), "w")