[Interpreter] Add support for LOOKUP_SLOT_CALL to interpreter.

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 1588 matching lines @@
   return first_arg;
 }
 
 
 void BytecodeGenerator::VisitCall(Call* expr) {
   Expression* callee_expr = expr->expression();
   Call::CallType call_type = expr->GetCallType(isolate());
 
   // Prepare the callee and the receiver to the function call. This depends on
   // 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
+  // Call(). We allocate the callee and receiver consecutively for calls to
+  // kLoadLookupSlot. 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);
+  execution_result()->PrepareForConsecutiveAllocations(args->length() + 2);
+  Register callee = execution_result()->NextConsecutiveRegister();
   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::LOOKUP_SLOT_CALL:
     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();
 
+        // Call LoadLookupSlot to get the callee and receiver.
+        DCHECK(Register::AreContiguous(callee, receiver));
         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);
+            .StoreAccumulatorInRegister(name)
+            .CallRuntimeForPair(Runtime::kLoadLookupSlot, context, 2, callee);
         break;
       }
       // Fall through.
+      DCHECK_EQ(call_type, Call::POSSIBLY_EVAL_CALL);
     }
     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:
       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);
 
   // Resolve callee for a potential direct eval call. This block will mutate the
   // callee value.
-  if (possibly_eval && args->length() > 0) {
+  if (call_type == Call::POSSIBLY_EVAL_CALL && 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
@@ skipping 590 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8