Revert of [modules] Store Module metadata in per-Context EmbedderData

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
 #include <fstream>
-#include <unordered_map>
+#include <map>
 #include <utility>
 #include <vector>
 
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
 #include "src/third_party/vtune/v8-vtune.h"
 #endif
 
 #include "src/d8.h"
 #include "src/ostreams.h"
 
@@ skipping 542 matching lines @@
     result = dir_name + '/' + path;
   }
   std::replace(result.begin(), result.end(), '\\', '/');
   size_t i;
   while ((i = result.find("/./")) != std::string::npos) {
     result.erase(i, 2);
   }
   return result;
 }
 
-// Per-context Module data, allowing sharing of module maps
-// across top-level module loads.
-class ModuleEmbedderData {
- private:
-  class ModuleGlobalHash {
-   public:
-    explicit ModuleGlobalHash(Isolate* isolate) : isolate_(isolate) {}
-    size_t operator()(const Global<Module>& module) const {
-      return module.Get(isolate_)->GetIdentityHash();
-    }
-
-   private:
-    Isolate* isolate_;
-  };
-
- public:
-  explicit ModuleEmbedderData(Isolate* isolate)
-      : module_to_directory_map(10, ModuleGlobalHash(isolate)) {}
-
-  // Map from normalized module specifier to Module.
-  std::unordered_map<std::string, Global<Module>> specifier_to_module_map;
-  // Map from Module to the directory that Module was loaded from.
-  std::unordered_map<Global<Module>, std::string, ModuleGlobalHash>
-      module_to_directory_map;
-};
-
-enum {
-  // The debugger reserves the first slot in the Context embedder data.
-  kDebugIdIndex = Context::kDebugIdIndex,
-  kModuleEmbedderDataIndex
-};
-
-void InitializeModuleEmbedderData(Local<Context> context) {
-  context->SetAlignedPointerInEmbedderData(
-      kModuleEmbedderDataIndex, new ModuleEmbedderData(context->GetIsolate()));
-}
-
-ModuleEmbedderData* GetModuleDataFromContext(Local<Context> context) {
-  return static_cast<ModuleEmbedderData*>(
-      context->GetAlignedPointerFromEmbedderData(kModuleEmbedderDataIndex));
-}
-
-void DisposeModuleEmbedderData(Local<Context> context) {
-  delete GetModuleDataFromContext(context);
-  context->SetAlignedPointerInEmbedderData(kModuleEmbedderDataIndex, nullptr);
-}
-
 MaybeLocal<Module> ResolveModuleCallback(Local<Context> context,
                                          Local<String> specifier,
-                                         Local<Module> referrer) {
+                                         Local<Module> referrer,
+                                         Local<Value> data) {
   Isolate* isolate = context->GetIsolate();
-  ModuleEmbedderData* d = GetModuleDataFromContext(context);
-  auto dir_name_it =
-      d->module_to_directory_map.find(Global<Module>(isolate, referrer));
-  CHECK(dir_name_it != d->module_to_directory_map.end());
+  auto module_map = static_cast<std::map<std::string, Global<Module>>*>(
+      External::Cast(*data)->Value());
+  Local<String> dir_name = Local<String>::Cast(referrer->GetEmbedderData());
   std::string absolute_path =
-      NormalizePath(ToSTLString(specifier), dir_name_it->second);
-  auto module_it = d->specifier_to_module_map.find(absolute_path);
-  CHECK(module_it != d->specifier_to_module_map.end());
-  return module_it->second.Get(isolate);
+      NormalizePath(ToSTLString(specifier), ToSTLString(dir_name));
+  auto it = module_map->find(absolute_path);
+  if (it != module_map->end()) {
+    return it->second.Get(isolate);
+  }
+  return MaybeLocal<Module>();
 }
 
 }  // anonymous namespace
 
-MaybeLocal<Module> Shell::FetchModuleTree(Local<Context> context,
-                                          const std::string& file_name) {
+MaybeLocal<Module> Shell::FetchModuleTree(
+    Isolate* isolate, const std::string& file_name,
+    std::map<std::string, Global<Module>>* module_map) {
   DCHECK(IsAbsolutePath(file_name));
-  Isolate* isolate = context->GetIsolate();
   TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
   Local<String> source_text = ReadFile(isolate, file_name.c_str());
   if (source_text.IsEmpty()) {
     printf("Error reading '%s'\n", file_name.c_str());
     Shell::Exit(1);
   }
   ScriptOrigin origin(
       String::NewFromUtf8(isolate, file_name.c_str(), NewStringType::kNormal)
           .ToLocalChecked());
   ScriptCompiler::Source source(source_text, origin);
   Local<Module> module;
   if (!ScriptCompiler::CompileModule(isolate, &source).ToLocal(&module)) {
     ReportException(isolate, &try_catch);
     return MaybeLocal<Module>();
   }
-
-  ModuleEmbedderData* d = GetModuleDataFromContext(context);
-  CHECK(d->specifier_to_module_map
-            .insert(std::make_pair(file_name, Global<Module>(isolate, module)))
-            .second);
+  module_map->insert(
+      std::make_pair(file_name, Global<Module>(isolate, module)));
 
   std::string dir_name = DirName(file_name);
-  CHECK(d->module_to_directory_map
-            .insert(std::make_pair(Global<Module>(isolate, module), dir_name))
-            .second);
+  module->SetEmbedderData(
+      String::NewFromUtf8(isolate, dir_name.c_str(), NewStringType::kNormal)
+          .ToLocalChecked());
 
   for (int i = 0, length = module->GetModuleRequestsLength(); i < length; ++i) {
     Local<String> name = module->GetModuleRequest(i);
     std::string absolute_path = NormalizePath(ToSTLString(name), dir_name);
-    if (!d->specifier_to_module_map.count(absolute_path)) {
-      if (FetchModuleTree(context, absolute_path).IsEmpty()) {
+    if (!module_map->count(absolute_path)) {
+      if (FetchModuleTree(isolate, absolute_path, module_map).IsEmpty()) {
         return MaybeLocal<Module>();
       }
     }
   }
 
   return module;
 }
 
 bool Shell::ExecuteModule(Isolate* isolate, const char* file_name) {
   HandleScope handle_scope(isolate);
 
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
-  Context::Scope context_scope(realm);
-
   std::string absolute_path = NormalizePath(file_name, GetWorkingDirectory());
 
   Local<Module> root_module;
-  if (!FetchModuleTree(realm, absolute_path).ToLocal(&root_module)) {
+  std::map<std::string, Global<Module>> module_map;
+  if (!FetchModuleTree(isolate, absolute_path, &module_map)
+           .ToLocal(&root_module)) {
     return false;
   }
 
   TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
 
   MaybeLocal<Value> maybe_result;
-  if (root_module->Instantiate(realm, ResolveModuleCallback)) {
-    maybe_result = root_module->Evaluate(realm);
-    EmptyMessageQueues(isolate);
+  {
+    PerIsolateData* data = PerIsolateData::Get(isolate);
+    Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
+    Context::Scope context_scope(realm);
+
+    if (root_module->Instantiate(realm, ResolveModuleCallback,
+                                 External::New(isolate, &module_map))) {
+      maybe_result = root_module->Evaluate(realm);
+      EmptyMessageQueues(isolate);
+    }
   }
   Local<Value> result;
   if (!maybe_result.ToLocal(&result)) {
     DCHECK(try_catch.HasCaught());
     // Print errors that happened during execution.
     ReportException(isolate, &try_catch);
     return false;
   }
   DCHECK(!try_catch.HasCaught());
   return true;
@@ skipping 109 matching lines @@
     old_realms[i].Reset();
   }
   delete[] old_realms;
   Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
   Local<Context> context = Context::New(isolate, NULL, global_template);
   if (context.IsEmpty()) {
     DCHECK(try_catch.HasCaught());
     try_catch.ReThrow();
     return MaybeLocal<Context>();
   }
-  InitializeModuleEmbedderData(context);
   data->realms_[index].Reset(isolate, context);
   args.GetReturnValue().Set(index);
   return context;
 }
 
 // Realm.create() creates a new realm with a distinct security token
 // and returns its index.
 void Shell::RealmCreate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CreateRealm(args);
 }
@@ skipping 13 matching lines @@
 void Shell::RealmDispose(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   PerIsolateData* data = PerIsolateData::Get(isolate);
   int index = data->RealmIndexOrThrow(args, 0);
   if (index == -1) return;
   if (index == 0 ||
       index == data->realm_current_ || index == data->realm_switch_) {
     Throw(args.GetIsolate(), "Invalid realm index");
     return;
   }
-  DisposeModuleEmbedderData(data->realms_[index].Get(isolate));
   data->realms_[index].Reset();
   isolate->ContextDisposedNotification();
   isolate->IdleNotificationDeadline(g_platform->MonotonicallyIncreasingTime());
 }
 
 
 // Realm.switch(i) switches to the realm i for consecutive interactive inputs.
 void Shell::RealmSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   PerIsolateData* data = PerIsolateData::Get(isolate);
@@ skipping 648 matching lines @@
 
 
 Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
   // This needs to be a critical section since this is not thread-safe
   base::LockGuard<base::Mutex> lock_guard(context_mutex_.Pointer());
   // Initialize the global objects
   Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
   EscapableHandleScope handle_scope(isolate);
   Local<Context> context = Context::New(isolate, NULL, global_template);
   DCHECK(!context.IsEmpty());
-  InitializeModuleEmbedderData(context);
   Context::Scope scope(context);
 
   i::Factory* factory = reinterpret_cast<i::Isolate*>(isolate)->factory();
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
       factory->NewFixedArray(js_args.argc);
   for (int j = 0; j < js_args.argc; j++) {
     i::Handle<i::String> arg =
         factory->NewStringFromUtf8(i::CStrVector(js_args[j])).ToHandleChecked();
     arguments_array->set(j, *arg);
@@ skipping 305 matching lines @@
       Isolate::Scope iscope(isolate);
       {
         HandleScope scope(isolate);
         PerIsolateData data(isolate);
         Local<Context> context = Shell::CreateEvaluationContext(isolate);
         {
           Context::Scope cscope(context);
           PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
           Execute(isolate);
         }
-        DisposeModuleEmbedderData(context);
       }
       Shell::CollectGarbage(isolate);
     }
     done_semaphore_.Signal();
   }
 
   isolate->Dispose();
 }
 
 
@@ skipping 239 matching lines @@
               if (Shell::DeserializeValue(isolate, *data, &offset)
                       .ToLocal(&data_value)) {
                 Local<Value> argv[] = {data_value};
                 (void)onmessage_fun->Call(context, global, 1, argv);
               }
               delete data;
             }
           }
         }
       }
-      DisposeModuleEmbedderData(context);
     }
     Shell::CollectGarbage(isolate);
   }
   isolate->Dispose();
 
   // Post NULL to wake the thread waiting on GetMessage() if there is one.
   out_queue_.Enqueue(NULL);
   out_semaphore_.Signal();
 }
 
@@ skipping 163 matching lines @@
     Local<Context> context = CreateEvaluationContext(isolate);
     if (last_run && options.use_interactive_shell()) {
       // Keep using the same context in the interactive shell.
       evaluation_context_.Reset(isolate, context);
     }
     {
       Context::Scope cscope(context);
       PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
       options.isolate_sources[0].Execute(isolate);
     }
-    DisposeModuleEmbedderData(context);
   }
   CollectGarbage(isolate);
   for (int i = 1; i < options.num_isolates; ++i) {
     if (last_run) {
       options.isolate_sources[i].JoinThread();
     } else {
       options.isolate_sources[i].WaitForThread();
     }
   }
   CleanupWorkers();
@@ skipping 496 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif