[Interpreter] Add support for calling eval.

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/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
@@ skipping 1597 matching lines @@
   // the semantics of the underlying call type.
   Register callee = execution_result()->NewRegister();
 
   // The receiver and arguments need to be allocated consecutively for
   // Call(). Future optimizations could avoid this there are no
   // arguments or the receiver and arguments are already consecutive.
   ZoneList<Expression*>* args = expr->arguments();
   execution_result()->PrepareForConsecutiveAllocations(args->length() + 1);
   Register receiver = execution_result()->NextConsecutiveRegister();
 
+  bool possibly_eval = false;
   switch (call_type) {
     case Call::NAMED_PROPERTY_CALL:
     case Call::KEYED_PROPERTY_CALL: {
       Property* property = callee_expr->AsProperty();
       VisitForAccumulatorValue(property->obj());
       builder()->StoreAccumulatorInRegister(receiver);
       VisitPropertyLoadForAccumulator(receiver, property);
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
     case Call::GLOBAL_CALL: {
       // Receiver is undefined for global calls.
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       // Load callee as a global variable.
       VariableProxy* proxy = callee_expr->AsVariableProxy();
       VisitVariableLoadForAccumulatorValue(proxy->var(),
                                            proxy->VariableFeedbackSlot());
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
+    case Call::POSSIBLY_EVAL_CALL: {
+      possibly_eval = true;
+      if (callee_expr->AsVariableProxy()->var()->IsLookupSlot()) {
+        TemporaryRegisterScope temporary_register_scope(builder());
+        temporary_register_scope.PrepareForConsecutiveAllocations(2);
+        Register context = temporary_register_scope.NextConsecutiveRegister();
+        Register name = temporary_register_scope.NextConsecutiveRegister();
+
+        Variable* variable = callee_expr->AsVariableProxy()->var();
+        builder()
+            ->MoveRegister(Register::function_context(), context)
+            .LoadLiteral(variable->name())
+            .StoreAccumulatorInRegister(name);
+
+        // Call LoadLookupSlotCallee/Receiver to get the Callee and Receiver

[Michael Starzinger, 2016/01/08 13:40:47]

nit: Comment is outdated, also s/Callee/callee/ and s/Receiver/receiver/ here.

[rmcilroy, 2016/01/08 14:34:30]

Done.

+        // Reuse the context and name arguments as the return registers (since
+        // these are consecutive), and them move into callee and reciever
+        // registers.
+        builder()
+            ->CallRuntimeForPair(Runtime::kLoadLookupSlot, context, 2, context)
+            .MoveRegister(context, callee)
+            .MoveRegister(name, receiver);
+        break;
+      }
+      // Fall through.
+    }
     case Call::OTHER_CALL: {
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       VisitForAccumulatorValue(callee_expr);
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
     case Call::NAMED_SUPER_PROPERTY_CALL:
     case Call::KEYED_SUPER_PROPERTY_CALL:
     case Call::LOOKUP_SLOT_CALL:
     case Call::SUPER_CALL:
-    case Call::POSSIBLY_EVAL_CALL:
       UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
   Register arg = VisitArguments(args);
   CHECK(args->length() == 0 || arg.index() == receiver.index() + 1);
 
-  // TODO(rmcilroy): Deal with possible direct eval here?
+  // Resolve callee and receiver for a potential direct eval call. This block
+  // will mutate the callee and receiver values.

[Michael Starzinger, 2016/01/08 13:40:47]

nit: This comment is outdated (also in the AstGraphBuilder), the below block no
longer mutates the receiver, it only mutates the callee value. Could you update
here (and if you feel like it also in the AstGraphBuilder)?

[rmcilroy, 2016/01/08 14:34:30]

Done (also in AstGraphBuilder).

+  if (possibly_eval && args->length() > 0) {
+    TemporaryRegisterScope temporary_register_scope(builder());
+    temporary_register_scope.PrepareForConsecutiveAllocations(5);
+    Register callee_for_eval =
+        temporary_register_scope.NextConsecutiveRegister();
+    Register source = temporary_register_scope.NextConsecutiveRegister();
+    Register function = temporary_register_scope.NextConsecutiveRegister();
+    Register language = temporary_register_scope.NextConsecutiveRegister();
+    Register position = temporary_register_scope.NextConsecutiveRegister();
+
+    // Set up arguments for ResolvePossiblyDirectEval by copying callee, source
+    // strings and function closure, and loading language and
+    // position.
+    builder()
+        ->MoveRegister(callee, callee_for_eval)
+        .MoveRegister(arg, source)
+        .MoveRegister(Register::function_closure(), function)
+        .LoadLiteral(Smi::FromInt(language_mode()))
+        .StoreAccumulatorInRegister(language)
+        .LoadLiteral(
+            Smi::FromInt(execution_context()->scope()->start_position()))
+        .StoreAccumulatorInRegister(position);
+
+    // Call ResolvePossiblyDirectEval and modify the callee.
+    builder()
+        ->CallRuntime(Runtime::kResolvePossiblyDirectEval, callee_for_eval, 5)
+        .StoreAccumulatorInRegister(callee);
+  }
+
   // TODO(rmcilroy): Use CallIC to allow call type feedback.
   builder()->Call(callee, receiver, args->length(),
                   feedback_index(expr->CallFeedbackICSlot()));
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitCallNew(CallNew* expr) {
   Register constructor = execution_result()->NewRegister();
   VisitForAccumulatorValue(expr->expression());
@@ skipping 377 matching lines @@
                            Register::function_closure(), 1);
   }
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitBuildLocalActivationContext() {
   Scope* scope = this->scope();
 
   if (scope->has_this_declaration() && scope->receiver()->IsContextSlot()) {
-    UNIMPLEMENTED();
+    Variable* variable = scope->receiver();
+    Register receiver(builder()->Parameter(0));
+    // Context variable (at bottom of the context chain).
+    DCHECK_EQ(0, scope->ContextChainLength(variable->scope()));
+    builder()->LoadAccumulatorWithRegister(receiver).StoreContextSlot(
+        execution_context()->reg(), variable->index());
   }
 
   // Copy parameters into context if necessary.
   int num_parameters = scope->num_parameters();
   for (int i = 0; i < num_parameters; i++) {
     Variable* variable = scope->parameter(i);
     if (!variable->IsContextSlot()) continue;
 
     // The parameter indices are shifted by 1 (receiver is variable
     // index -1 but is parameter index 0 in BytecodeArrayBuilder).
@@ skipping 159 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8