[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 LoadLookupSlot to get the callee and receiver. Reuse the context
+        // and name arguments as the return registers (since these are
+        // consecutive), and them move into callee and receiver 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 for a potential direct eval call. This block will mutate the
+  // callee value.
+  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