[modules] Assign cell indices at validation time.

src/objects.cc

 // Copyright 2015 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 "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 19889 matching lines @@
             &loc);
       }
       return MaybeHandle<Cell>();
     }
     name_set->insert(name);
   }
 
   if (object->IsModuleInfoEntry()) {
     // Not yet resolved indirect export.
     Handle<ModuleInfoEntry> entry = Handle<ModuleInfoEntry>::cast(object);
-    int module_request = Smi::cast(entry->module_request())->value();
     Handle<String> import_name(String::cast(entry->import_name()), isolate);
     Handle<Script> script(
         Script::cast(JSFunction::cast(module->code())->shared()->script()),
         isolate);
     MessageLocation new_loc(script, entry->beg_pos(), entry->end_pos());
 
     Handle<Cell> cell;
-    if (!ResolveImport(module, import_name, module_request, new_loc, true,
-                       resolve_set)
+    if (!ResolveImport(module, import_name, entry->module_request(), new_loc,
+                       true, resolve_set)
              .ToHandle(&cell)) {
       DCHECK(isolate->has_pending_exception());
       return MaybeHandle<Cell>();
     }
 
     // The export table may have changed but the entry in question should be
     // unchanged.
     Handle<ObjectHashTable> exports(module->exports(), isolate);
     DCHECK(exports->Lookup(name)->IsModuleInfoEntry());
 
@@ skipping 16 matching lines @@
     // exports provide the name, make sure they all map it to the same cell.
     Handle<Cell> unique_cell;
     Handle<FixedArray> special_exports(module->info()->special_exports(),
                                        isolate);
     for (int i = 0, n = special_exports->length(); i < n; ++i) {
       i::Handle<i::ModuleInfoEntry> entry(
           i::ModuleInfoEntry::cast(special_exports->get(i)), isolate);
       if (!entry->export_name()->IsUndefined(isolate)) {
         continue;  // Indirect export.
       }
-      int module_request = Smi::cast(entry->module_request())->value();
 
       Handle<Script> script(
           Script::cast(JSFunction::cast(module->code())->shared()->script()),
           isolate);
       MessageLocation new_loc(script, entry->beg_pos(), entry->end_pos());
 
       Handle<Cell> cell;
-      if (ResolveImport(module, name, module_request, new_loc, false,
+      if (ResolveImport(module, name, entry->module_request(), new_loc, false,
                         resolve_set)
               .ToHandle(&cell)) {
         if (unique_cell.is_null()) unique_cell = cell;
         if (*unique_cell != *cell) {
           return isolate->Throw<Cell>(
               isolate->factory()->NewSyntaxError(
                   MessageTemplate::kAmbiguousExport, name),
               &loc);
         }
       } else if (isolate->has_pending_exception()) {
@@ skipping 32 matching lines @@
           shared,
           handle(Utils::OpenHandle(*context)->native_context(), isolate));
   module->set_code(*function);
   DCHECK(module->instantiated());
 
   Handle<ModuleInfo> module_info(shared->scope_info()->ModuleDescriptorInfo(),
                                  isolate);
 
   // Set up local exports.
   Handle<FixedArray> regular_exports(module_info->regular_exports(), isolate);
-  for (int i = 0, n = regular_exports->length(); i < n; i += 2) {
+  for (int i = 0, n = regular_exports->length(); i < n; i += 3) {
+    // TODO(neis): Make this more robust.

[adamk, 2016/10/31 18:25:04]

Related to robustness, seems like this loop should be bounded in a safer way.

[neis, 2016/11/03 10:43:48]

Sure, that's part of it.

     Handle<FixedArray> export_names(
-        FixedArray::cast(regular_exports->get(i + 1)), isolate);
+        FixedArray::cast(regular_exports->get(i + 2)), isolate);
     CreateExport(module, export_names);
   }
 
   // Partially set up indirect exports.
   // For each indirect export, we create the appropriate slot in the export
   // table and store its ModuleInfoEntry there.  When we later find the correct
   // Cell in the module that actually provides the value, we replace the
   // ModuleInfoEntry by that Cell (see ResolveExport).
   Handle<FixedArray> special_exports(module_info->special_exports(), isolate);
   for (int i = 0, n = special_exports->length(); i < n; ++i) {
@@ skipping 27 matching lines @@
   }
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   // Resolve imports.
   Handle<FixedArray> regular_imports(module_info->regular_imports(), isolate);
   for (int i = 0, n = regular_imports->length(); i < n; ++i) {
     Handle<ModuleInfoEntry> entry(
         ModuleInfoEntry::cast(regular_imports->get(i)), isolate);
     Handle<String> name(String::cast(entry->import_name()), isolate);
-    int module_request = Smi::cast(entry->module_request())->value();
     Handle<Script> script(
         Script::cast(JSFunction::cast(module->code())->shared()->script()),
         isolate);
     MessageLocation loc(script, entry->beg_pos(), entry->end_pos());
     ResolveSet resolve_set(&zone);
-    if (ResolveImport(module, name, module_request, loc, true, &resolve_set)
+    if (ResolveImport(module, name, entry->module_request(), loc, true,
+                      &resolve_set)
             .is_null()) {
       return false;
     }
   }
 
   // Resolve indirect exports.
   for (int i = 0, n = special_exports->length(); i < n; ++i) {
     Handle<ModuleInfoEntry> entry(
         ModuleInfoEntry::cast(special_exports->get(i)), isolate);
     Handle<Object> name(entry->export_name(), isolate);
@@ skipping 63 matching lines @@
 
   Handle<FixedArray> special_exports(module->info()->special_exports(),
                                      isolate);
   for (int i = 0, n = special_exports->length(); i < n; ++i) {
     Handle<ModuleInfoEntry> entry(
         ModuleInfoEntry::cast(special_exports->get(i)), isolate);
     if (!entry->export_name()->IsUndefined(isolate)) {
       continue;  // Indirect export.
     }
 
-    int module_request = Smi::cast(entry->module_request())->value();
     Handle<Module> requested_module(
-        Module::cast(module->requested_modules()->get(module_request)),
+        Module::cast(module->requested_modules()->get(entry->module_request())),
         isolate);
 
     // Recurse.
     FetchStarExports(requested_module, zone, visited);
 
     // Collect all of [requested_module]'s exports that must be added to
     // [module]'s exports (i.e. to [exports]).  We record these in
     // [more_exports].  Ambiguities (conflicting exports) are marked by mapping
     // the name to undefined instead of a Cell.
     Handle<ObjectHashTable> requested_exports(requested_module->exports(),
@@ skipping 87 matching lines @@
         ns, Accessors::ModuleNamespaceEntryInfo(isolate, name, attr))
         .Check();
   }
   JSObject::PreventExtensions(ns, THROW_ON_ERROR).ToChecked();
 
   return ns;
 }
 
 }  // namespace internal
 }  // namespace v8