[interpreter] Add fast path for dynamic global lookups

src/interpreter/interpreter.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/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 403 matching lines @@
 //
 // Stores the value of register <src> to register <dst>.
 void Interpreter::DoMov(InterpreterAssembler* assembler) {
   Node* src_index = __ BytecodeOperandReg(0);
   Node* src_value = __ LoadRegister(src_index);
   Node* dst_index = __ BytecodeOperandReg(1);
   __ StoreRegister(src_value, dst_index);
   __ Dispatch();
 }
 
-Node* Interpreter::BuildLoadGlobal(Callable ic,
+Node* Interpreter::BuildLoadGlobal(Callable ic, Node* context, Node* raw_slot,

[rmcilroy, 2016/09/19 09:04:29]

nit - rename raw_slot to feedback_slot (in header too)

[Leszek Swirski, 2016/09/19 10:34:51]

Done.

                                    InterpreterAssembler* assembler) {
   typedef LoadGlobalWithVectorDescriptor Descriptor;
-  // Get the global object.
-  Node* context = __ GetContext();
 
   // Load the global via the LoadGlobalIC.
   Node* code_target = __ HeapConstant(ic.code());
-  Node* raw_slot = __ BytecodeOperandIdx(0);
   Node* smi_slot = __ SmiTag(raw_slot);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   return __ CallStub(ic.descriptor(), code_target, context,
                      Arg(Descriptor::kSlot, smi_slot),
                      Arg(Descriptor::kVector, type_feedback_vector));
 }
 
+Node* Interpreter::BuildLoadGlobal(Callable ic,

[rmcilroy, 2016/09/19 09:04:29]

Not sure it's worth having this helper - would probably be as clear just
inlining this code in LdaGlobal

[Leszek Swirski, 2016/09/19 10:34:51]

Fair enough, done (or rather, undone).

+                                   InterpreterAssembler* assembler) {
+  // Get the global object.
+  Node* context = __ GetContext();
+
+  Node* raw_slot = __ BytecodeOperandIdx(0);
+  return BuildLoadGlobal(ic, context, raw_slot, assembler);
+}
+
 // LdaGlobal <slot>
 //
 // Load the global with name in constant pool entry <name_index> into the
 // accumulator using FeedBackVector slot <slot> outside of a typeof.
 void Interpreter::DoLdaGlobal(InterpreterAssembler* assembler) {
   Callable ic =
       CodeFactory::LoadGlobalICInOptimizedCode(isolate_, NOT_INSIDE_TYPEOF);
   Node* result = BuildLoadGlobal(ic, assembler);
   __ SetAccumulator(result);
   __ Dispatch();
@@ skipping 104 matching lines @@
   Node* value = __ GetAccumulator();
   Node* reg_index = __ BytecodeOperandReg(0);
   Node* context = __ LoadRegister(reg_index);
   Node* slot_index = __ BytecodeOperandIdx(1);
   Node* depth = __ BytecodeOperandUImm(2);
   Node* slot_context = __ GetContextAtDepth(context, depth);
   __ StoreContextSlot(slot_context, slot_index, value);
   __ Dispatch();
 }
 
+void Interpreter::DoLdaLookupSlowPath(Runtime::FunctionId function_id,
+                                      Node* name_index, Node* context,
+                                      InterpreterAssembler* assembler) {
+  Node* name = __ LoadConstantPoolEntry(name_index);
+  Node* result = __ CallRuntime(function_id, context, name);
+  __ SetAccumulator(result);
+  __ Dispatch();

[rmcilroy, 2016/09/19 09:04:29]

I'd prefer you made this BuildLdaLookupSlowPath and returned the result and did
the dispatch in the bytecode handler itself (at which point it probably the same
number of lines just to inline the code).

[Leszek Swirski, 2016/09/19 10:34:51]

Done.

+}
+
 void Interpreter::DoLdaLookupSlot(Runtime::FunctionId function_id,
                                   InterpreterAssembler* assembler) {
   Node* index = __ BytecodeOperandIdx(0);
-  Node* name = __ LoadConstantPoolEntry(index);
   Node* context = __ GetContext();
-  Node* result = __ CallRuntime(function_id, context, name);
-  __ SetAccumulator(result);
-  __ Dispatch();
+  DoLdaLookupSlowPath(function_id, index, context, assembler);
 }
 
 // LdaLookupSlot <name_index>
 //
 // Lookup the object with the name in constant pool entry |name_index|
 // dynamically.
 void Interpreter::DoLdaLookupSlot(InterpreterAssembler* assembler) {
   DoLdaLookupSlot(Runtime::kLoadLookupSlot, assembler);
 }
 
@@ skipping 20 matching lines @@
   // Fast path does a normal load context.
   {
     Node* slot_context = __ GetContextAtDepth(context, depth);
     Node* result = __ LoadContextSlot(slot_context, slot_index);
     __ SetAccumulator(result);
     __ Dispatch();
   }
 
   // Slow path when we have to call out to the runtime.
   __ Bind(&slowpath);
-  {
-    Node* name = __ LoadConstantPoolEntry(name_index);
-    Node* result = __ CallRuntime(function_id, context, name);
-    __ SetAccumulator(result);
-    __ Dispatch();
-  }
+  { DoLdaLookupSlowPath(function_id, name_index, context, assembler); }
 }
 
 // LdaLookupSlot <name_index>
 //
 // Lookup the object with the name in constant pool entry |name_index|
 // dynamically.
 void Interpreter::DoLdaLookupContextSlot(InterpreterAssembler* assembler) {
   DoLdaLookupContextSlot(Runtime::kLoadLookupSlot, assembler);
 }
 
 // LdaLookupSlotInsideTypeof <name_index>
 //
 // Lookup the object with the name in constant pool entry |name_index|
 // dynamically without causing a NoReferenceError.
 void Interpreter::DoLdaLookupContextSlotInsideTypeof(
     InterpreterAssembler* assembler) {
   DoLdaLookupContextSlot(Runtime::kLoadLookupSlotInsideTypeof, assembler);
 }
 
+void Interpreter::DoLdaLookupGlobalSlot(Runtime::FunctionId function_id,
+                                        InterpreterAssembler* assembler) {
+  Node* context = __ GetContext();
+  Node* name_index = __ BytecodeOperandIdx(0);
+  Node* raw_slot = __ BytecodeOperandIdx(1);

[rmcilroy, 2016/09/19 09:04:29]

nit - slot_index

[Leszek Swirski, 2016/09/19 10:34:51]

Changed to feedback_slot, to match the parameter name in BuildLoadGlobal

+  Node* depth = __ BytecodeOperandUImm(2);
+
+  Label slowpath(assembler, Label::kDeferred);
+
+  // Check for context extensions to allow the fast path
+  __ GotoIfHasContextExtensionUpToDepth(context, depth, &slowpath);
+
+  // Fast path does a normal load global
+  {
+    Callable ic = CodeFactory::LoadGlobalICInOptimizedCode(
+        isolate_, function_id == Runtime::kLoadLookupSlotInsideTypeof
+                      ? INSIDE_TYPEOF
+                      : NOT_INSIDE_TYPEOF);
+    Node* result = BuildLoadGlobal(ic, context, raw_slot, assembler);
+    __ SetAccumulator(result);
+    __ Dispatch();
+  }
+
+  // Slow path when we have to call out to the runtime
+  __ Bind(&slowpath);
+  { DoLdaLookupSlowPath(function_id, name_index, context, assembler); }
+}
+
+// LdaLookupSlot <name_index>
+//
+// Lookup the object with the name in constant pool entry |name_index|
+// dynamically.
+void Interpreter::DoLdaLookupGlobalSlot(InterpreterAssembler* assembler) {
+  DoLdaLookupGlobalSlot(Runtime::kLoadLookupSlot, assembler);
+}
+
+// LdaLookupSlotInsideTypeof <name_index>
+//
+// Lookup the object with the name in constant pool entry |name_index|
+// dynamically without causing a NoReferenceError.
+void Interpreter::DoLdaLookupGlobalSlotInsideTypeof(
+    InterpreterAssembler* assembler) {
+  DoLdaLookupGlobalSlot(Runtime::kLoadLookupSlotInsideTypeof, assembler);
+}
+
 void Interpreter::DoStaLookupSlot(LanguageMode language_mode,
                                   InterpreterAssembler* assembler) {
   Node* value = __ GetAccumulator();
   Node* index = __ BytecodeOperandIdx(0);
   Node* name = __ LoadConstantPoolEntry(index);
   Node* context = __ GetContext();
   Node* result = __ CallRuntime(is_strict(language_mode)
                                     ? Runtime::kStoreLookupSlot_Strict
                                     : Runtime::kStoreLookupSlot_Sloppy,
                                 context, name, value);
@@ skipping 1866 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8