[Interpreter] Add support for loading globals in the 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 <stack>
 
 #include "src/compiler.h"
 #include "src/objects.h"
@@ skipping 233 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitVariableProxy(VariableProxy* proxy) {
-  Variable* variable = proxy->var();
+  VisitVariableLoad(proxy->var());
+}
+
+
+void BytecodeGenerator::VisitVariableLoad(Variable* variable) {
   switch (variable->location()) {
     case VariableLocation::LOCAL: {
       Register source(variable->index());
       builder().LoadAccumulatorWithRegister(source);
       break;
     }
     case VariableLocation::PARAMETER: {
       // The parameter indices are shifted by 1 (receiver is variable
       // index -1 but is parameter index 0 in BytecodeArrayBuilder).
       Register source(builder().Parameter(variable->index() + 1));
       builder().LoadAccumulatorWithRegister(source);
       break;
     }
-    case VariableLocation::GLOBAL:
+    case VariableLocation::GLOBAL: {
+      // Global var, const, or let variable.
+      // TODO(rmcilroy): If context chain depth is short enough, do this using
+      // a generic version of LoadGlobalViaContextStub rather than calling the
+      // runtime.
+      DCHECK(variable->IsStaticGlobalObjectProperty());
+      builder().LoadGlobal(variable->index());
+      break;
+    }
     case VariableLocation::UNALLOCATED:
     case VariableLocation::CONTEXT:
     case VariableLocation::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   DCHECK(expr->target()->IsValidReferenceExpression());
@@ skipping 117 matching lines @@
       if (property->IsSuperAccess()) {
         UNIMPLEMENTED();
       }
       Visit(property->obj());
       builder().StoreAccumulatorInRegister(receiver);
       // Perform a property load of the callee.
       VisitPropertyLoad(receiver, property);
       builder().StoreAccumulatorInRegister(callee);
       break;
     }
-    case Call::GLOBAL_CALL:
+    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();
+      VisitVariableLoad(proxy->var());
+      builder().StoreAccumulatorInRegister(callee);
+      break;
+    }
     case Call::LOOKUP_SLOT_CALL:
     case Call::SUPER_CALL:
     case Call::POSSIBLY_EVAL_CALL:
     case Call::OTHER_CALL:
       UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
   ZoneList<Expression*>* args = expr->arguments();
@@ skipping 89 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorICSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8