[ignition] Add lookup fast path to generated turbofan graph

src/compiler/bytecode-graph-builder.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/compiler/bytecode-graph-builder.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compilation-info.h"
 #include "src/compiler/bytecode-branch-analysis.h"
@@ skipping 871 matching lines @@
 
 void BytecodeGraphBuilder::VisitLdaLookupSlot() {
   BuildLdaLookupSlot(TypeofMode::NOT_INSIDE_TYPEOF);
 }
 
 void BytecodeGraphBuilder::VisitLdaLookupSlotInsideTypeof() {
   BuildLdaLookupSlot(TypeofMode::INSIDE_TYPEOF);
 }
 
 void BytecodeGraphBuilder::BuildLdaLookupContextSlot(TypeofMode typeof_mode) {
-  // TODO(leszeks): Build the fast path here.
+  uint32_t depth = bytecode_iterator().GetUnsignedImmediateOperand(2);
+
+  // Check if any context in the depth has an extension.
+  Environment* slow_environment = nullptr;
+
+  for (uint32_t d = 0; d < depth; d++) {

[Michael Starzinger, 2016/09/28 13:55:21]

Shouldn't this be "<=" here? IIUC we also want to do an extension check on the
actual target context itself as well. Unless I am missing something.

Also, is InterpreterAssembler::GotoIfHasContextExtensionUpToDepth suffering from
the same problem?

+    Node* extension_slot =
+        NewNode(javascript()->LoadContext(d, Context::EXTENSION_INDEX, false),
+                environment()->Context());
+
+    Node* check_no_extension =
+        NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
+                extension_slot, jsgraph()->TheHoleConstant());
+
+    NewBranch(check_no_extension);
+    Environment* false_environment = environment();
+    Environment* true_environment = environment()->CopyForConditional();
+
+    {
+      set_environment(false_environment);
+      NewIfFalse();
+      // If there is an extension, merge into the slow path.
+      if (slow_environment == nullptr) {
+        slow_environment = false_environment;
+        NewMerge();
+      } else {
+        slow_environment->Merge(false_environment);
+      }
+    }
+
+    {
+      set_environment(true_environment);
+      NewIfTrue();
+      // Do nothing on if there is no extension, eventually falling through to
+      // the fast path.
+    }
+  }
+
+  // Fast path, do a context load.
+  {
+    uint32_t slot_index = bytecode_iterator().GetIndexOperand(1);
+
+    const Operator* op = javascript()->LoadContext(depth, slot_index, false);
+    Node* context = environment()->Context();
+    environment()->BindAccumulator(NewNode(op, context));
+    NewMerge();
+  }
+  Environment* fast_environment = environment();
 
   // Slow path, do a runtime load lookup.
+  set_environment(slow_environment);
   {
     FrameStateBeforeAndAfter states(this);
 
     Node* name =
         jsgraph()->Constant(bytecode_iterator().GetConstantForIndexOperand(0));
 
     const Operator* op =
         javascript()->CallRuntime(typeof_mode == TypeofMode::NOT_INSIDE_TYPEOF
                                       ? Runtime::kLoadLookupSlot
                                       : Runtime::kLoadLookupSlotInsideTypeof);
     Node* value = NewNode(op, name);
     environment()->BindAccumulator(value, &states);
   }
+
+  fast_environment->Merge(slow_environment);
+  set_environment(fast_environment);
 }
 
 void BytecodeGraphBuilder::VisitLdaLookupContextSlot() {
   BuildLdaLookupContextSlot(TypeofMode::NOT_INSIDE_TYPEOF);
 }
 
 void BytecodeGraphBuilder::VisitLdaLookupContextSlotInsideTypeof() {
   BuildLdaLookupContextSlot(TypeofMode::INSIDE_TYPEOF);
 }
 
@@ skipping 1220 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8