[ignition,modules] Introduce bytecodes for loading/storing module variables.

src/interpreter/bytecode-generator.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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 1847 matching lines @@
           builder()->LoadLookupGlobalSlot(variable->name(), typeof_mode,
                                           feedback_index(slot), depth);
           break;
         }
         default:
           builder()->LoadLookupSlot(variable->name(), typeof_mode);
       }
       break;
     }
     case VariableLocation::MODULE: {
-      Register index = register_allocator()->NewRegister();
-      builder()
-          ->LoadLiteral(Smi::FromInt(variable->index()))
-          .StoreAccumulatorInRegister(index)
-          .CallRuntime(Runtime::kLoadModuleVariable, index);
+      int depth = execution_context()->ContextChainDepth(variable->scope());
+      builder()->LoadModuleVariable(variable->index(), depth);
       if (hole_check_mode == HoleCheckMode::kRequired) {
         BuildThrowIfHole(variable->name());
       }
       break;
     }
   }
 }
 
 void BytecodeGenerator::BuildVariableLoadForAccumulatorValue(
     Variable* variable, FeedbackVectorSlot slot, HoleCheckMode hole_check_mode,
@@ skipping 147 matching lines @@
       if (mode == CONST && op != Token::INIT) {
         builder()->CallRuntime(Runtime::kThrowConstAssignError);
         break;
       }
 
       // If we don't throw above, we know that we're dealing with an
       // export because imports are const and we do not generate initializing
       // assignments for them.
       DCHECK(variable->IsExport());
 
-      RegisterList args = register_allocator()->NewRegisterList(2);
-      builder()
-          ->StoreAccumulatorInRegister(args[1])
-          .LoadLiteral(Smi::FromInt(variable->index()))
-          .StoreAccumulatorInRegister(args[0]);
+      int depth = execution_context()->ContextChainDepth(variable->scope());
       if (hole_check_mode == HoleCheckMode::kRequired) {
-        builder()->CallRuntime(Runtime::kLoadModuleVariable, args[0]);
+        Register value_temp = register_allocator()->NewRegister();
+        builder()
+            ->StoreAccumulatorInRegister(value_temp)
+            .LoadModuleVariable(variable->index(), depth);
         BuildHoleCheckForVariableAssignment(variable, op);
+        builder()->LoadAccumulatorWithRegister(value_temp);
       }
-      builder()
-          ->CallRuntime(Runtime::kStoreModuleVariable, args)
-          .LoadAccumulatorWithRegister(args[1]);
+      builder()->StoreModuleVariable(variable->index(), depth);
       break;
     }
   }
 }
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
   Register object, key;
   RegisterList super_property_args;
   Handle<String> name;
@@ skipping 1133 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8