[ESNext] Implement DynamicImportCall

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/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 617 matching lines @@
       global_declarations_(0, info->zone()),
       function_literals_(0, info->zone()),
       native_function_literals_(0, info->zone()),
       object_literals_(0, info->zone()),
       array_literals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
       generator_state_(),
-      loop_depth_(0) {
+      loop_depth_(0),
+      source_url_entry_(0),
+      has_source_url_entry_(false) {
   DCHECK_EQ(closure_scope(), closure_scope()->GetClosureScope());
 }
 
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(Isolate* isolate) {
   AllocateDeferredConstants(isolate);
   if (HasStackOverflow()) return Handle<BytecodeArray>();
   return builder()->ToBytecodeArray(isolate);
 }
 
 void BytecodeGenerator::AllocateDeferredConstants(Isolate* isolate) {
@@ skipping 40 matching lines @@
     }
   }
 
   // Build array literal constant elements
   for (std::pair<ArrayLiteral*, size_t> literal : array_literals_) {
     ArrayLiteral* array_literal = literal.first;
     Handle<ConstantElementsPair> constant_elements =
         array_literal->GetOrBuildConstantElements(isolate);
     builder()->SetDeferredConstantPoolEntry(literal.second, constant_elements);
   }
+
+  if (has_source_url_entry()) {
+    Handle<String> url(String::cast(info()->script()->name()));
+    builder()->SetDeferredConstantPoolEntry(source_url_entry(), url);
+  }
 }
 
 void BytecodeGenerator::GenerateBytecode(uintptr_t stack_limit) {
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
 
   InitializeAstVisitor(stack_limit);
 
   // Initialize the incoming context.
@@ skipping 2287 matching lines @@
   builder()->SetExpressionPosition(expr);
   builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
 }
 
 void BytecodeGenerator::VisitSpread(Spread* expr) { Visit(expr->expression()); }
 
 void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
   UNREACHABLE();
 }
 
+void BytecodeGenerator::VisitImportCallExpression(ImportCallExpression* expr) {
+  size_t entry;
+  if (has_source_url_entry()) {
+    entry = source_url_entry();
+  } else {
+    entry = builder()->AllocateDeferredConstantPoolEntry();

[rmcilroy, 2017/03/16 09:12:38]

Instead of storing this seperately, could you just pass the JSFunction
(Register::function_closure()) to the runtime call and load the script name off
the SharedFunctionInfo?

[gsathya, 2017/03/17 00:47:22]

Done.

+    set_source_url_entry(entry);
+  }
+
+  RegisterList args = register_allocator()->NewRegisterList(2);
+  VisitForRegisterValue(expr->argument(), args[1]);
+  builder()
+      ->LoadConstantPoolEntry(entry)
+      .StoreAccumulatorInRegister(args[0])
+      .CallRuntime(Runtime::kDynamicImportCall, args);
+}
+
 void BytecodeGenerator::VisitGetIterator(GetIterator* expr) {
   FeedbackSlot load_slot = expr->IteratorPropertyFeedbackSlot();
   FeedbackSlot call_slot = expr->IteratorCallFeedbackSlot();
 
   RegisterList args = register_allocator()->NewRegisterList(1);
   Register method = register_allocator()->NewRegister();
   Register obj = args[0];
 
   VisitForAccumulatorValue(expr->iterable());
 
@@ skipping 472 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8