[turbofan] Optimize variable loads in DYNAMIC_GLOBAL mode.

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/js-type-feedback.h"
@@ skipping 1694 matching lines @@
   // Transform both the class literal and the prototype to fast properties.
   const Operator* op = javascript()->CallRuntime(Runtime::kToFastProperties, 1);
   NewNode(op, environment()->Pop());  // prototype
   NewNode(op, environment()->Pop());  // literal
 
   // Assign to class variable.
   if (expr->scope() != NULL) {
     DCHECK_NOT_NULL(expr->class_variable_proxy());
     Variable* var = expr->class_variable_proxy()->var();
     FrameStateBeforeAndAfter states(this, BailoutId::None());
-    BuildVariableAssignment(states, var, literal, Token::INIT_CONST,
-                            BailoutId::None());
+    BuildVariableAssignment(var, literal, Token::INIT_CONST, BailoutId::None(),
+                            states);
   }
 
   ast_context()->ProduceValue(literal);
 }
 
 
 void AstGraphBuilder::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   UNREACHABLE();
 }
 
 
 void AstGraphBuilder::VisitConditional(Conditional* expr) {
   IfBuilder compare_if(this);
   VisitForTest(expr->condition());
   Node* condition = environment()->Pop();
   compare_if.If(condition);
   compare_if.Then();
   Visit(expr->then_expression());
   compare_if.Else();
   Visit(expr->else_expression());
   compare_if.End();
   ast_context()->ReplaceValue();
 }
 
 
 void AstGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   VectorSlotPair pair = CreateVectorSlotPair(expr->VariableFeedbackSlot());
   FrameStateBeforeAndAfter states(this, BeforeId(expr));
-  Node* value = BuildVariableLoad(states, expr->var(), expr->id(), pair,
+  Node* value = BuildVariableLoad(expr->var(), expr->id(), states, pair,
                                   ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitLiteral(Literal* expr) {
   Node* value = jsgraph()->Constant(expr->value());
   ast_context()->ProduceValue(value);
 }
 
@@ skipping 291 matching lines @@
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->AsProperty();
   LhsKind assign_type = DetermineLhsKind(expr);
 
   // Evaluate LHS expression and store the value.
   switch (assign_type) {
     case VARIABLE: {
       Variable* var = expr->AsVariableProxy()->var();
       FrameStateBeforeAndAfter states(this, BailoutId::None());
-      BuildVariableAssignment(states, var, value, Token::ASSIGN, bailout_id);
+      BuildVariableAssignment(var, value, Token::ASSIGN, bailout_id, states);
       break;
     }
     case NAMED_PROPERTY: {
       environment()->Push(value);
       VisitForValue(property->obj());
       FrameStateBeforeAndAfter states(this, property->obj()->id());
       Node* object = environment()->Pop();
       value = environment()->Pop();
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
       Node* store =
@@ skipping 51 matching lines @@
   // the left-hand side value and performing a binary operation.
   if (expr->is_compound()) {
     Node* old_value = NULL;
     switch (assign_type) {
       case VARIABLE: {
         VariableProxy* proxy = expr->target()->AsVariableProxy();
         VectorSlotPair pair =
             CreateVectorSlotPair(proxy->VariableFeedbackSlot());
         FrameStateBeforeAndAfter states(this, BeforeId(proxy));
         old_value =
-            BuildVariableLoad(states, proxy->var(), expr->target()->id(), pair,
+            BuildVariableLoad(proxy->var(), expr->target()->id(), states, pair,
                               OutputFrameStateCombine::Push());
         break;
       }
       case NAMED_PROPERTY: {
         Node* object = environment()->Top();
         Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
         VectorSlotPair pair =
             CreateVectorSlotPair(property->PropertyFeedbackSlot());
         FrameStateBeforeAndAfter states(this, property->obj()->id());
         old_value = BuildNamedLoad(object, name, pair);
@@ skipping 34 matching lines @@
       before_store_id = expr->value()->id();
     }
   }
 
   FrameStateBeforeAndAfter store_states(this, before_store_id);
   // Store the value.
   Node* value = environment()->Pop();
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->target()->AsVariableProxy()->var();
-      BuildVariableAssignment(store_states, variable, value, expr->op(),
-                              expr->id(), ast_context()->GetStateCombine());
+      BuildVariableAssignment(variable, value, expr->op(), expr->id(),
+                              store_states, ast_context()->GetStateCombine());
       break;
     }
     case NAMED_PROPERTY: {
       Node* object = environment()->Pop();
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
       Node* store =
           BuildNamedStore(object, name, value, expr->AssignmentFeedbackId());
       store_states.AddToNode(store, expr->id(),
                              ast_context()->GetStateCombine());
       break;
@@ skipping 67 matching lines @@
   CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS;
   Node* receiver_value = NULL;
   Node* callee_value = NULL;
   bool possibly_eval = false;
   switch (call_type) {
     case Call::GLOBAL_CALL: {
       VariableProxy* proxy = callee->AsVariableProxy();
       VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
       FrameStateBeforeAndAfter states(this, BeforeId(proxy));
       callee_value =
-          BuildVariableLoad(states, proxy->var(), expr->expression()->id(),
+          BuildVariableLoad(proxy->var(), expr->expression()->id(), states,
                             pair, OutputFrameStateCombine::Push());
       receiver_value = jsgraph()->UndefinedConstant();
       break;
     }
     case Call::LOOKUP_SLOT_CALL: {
       Variable* variable = callee->AsVariableProxy()->var();
       DCHECK(variable->location() == Variable::LOOKUP);
       Node* name = jsgraph()->Constant(variable->name());
       const Operator* op =
           javascript()->CallRuntime(Runtime::kLoadLookupSlot, 2);
@@ skipping 207 matching lines @@
 
   // Evaluate LHS expression and get old value.
   Node* old_value = NULL;
   int stack_depth = -1;
   switch (assign_type) {
     case VARIABLE: {
       VariableProxy* proxy = expr->expression()->AsVariableProxy();
       VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
       FrameStateBeforeAndAfter states(this, BeforeId(proxy));
       old_value =
-          BuildVariableLoad(states, proxy->var(), expr->expression()->id(),
+          BuildVariableLoad(proxy->var(), expr->expression()->id(), states,
                             pair, OutputFrameStateCombine::Push());
       stack_depth = 0;
       break;
     }
     case NAMED_PROPERTY: {
       VisitForValue(property->obj());
       FrameStateBeforeAndAfter states(this, property->obj()->id());
       Node* object = environment()->Top();
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
       VectorSlotPair pair =
@@ skipping 43 matching lines @@
     // before.
     states.AddToNode(value, BailoutId::None(),
                      OutputFrameStateCombine::Ignore());
   }
 
   // Store the value.
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->expression()->AsVariableProxy()->var();
       environment()->Push(value);
-      BuildVariableAssignment(store_states, variable, value, expr->op(),
-                              expr->AssignmentId());
+      BuildVariableAssignment(variable, value, expr->op(), expr->AssignmentId(),
+                              store_states);
       environment()->Pop();
       break;
     }
     case NAMED_PROPERTY: {
       Node* object = environment()->Pop();
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
       Node* store =
           BuildNamedStore(object, name, value, expr->CountStoreFeedbackId());
       environment()->Push(value);
       store_states.AddToNode(store, expr->AssignmentId(),
@@ skipping 182 matching lines @@
 
 void AstGraphBuilder::VisitTypeof(UnaryOperation* expr) {
   Node* operand;
   if (expr->expression()->IsVariableProxy()) {
     // Typeof does not throw a reference error on global variables, hence we
     // perform a non-contextual load in case the operand is a variable proxy.
     VariableProxy* proxy = expr->expression()->AsVariableProxy();
     VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
     FrameStateBeforeAndAfter states(this, BeforeId(proxy));
     operand =
-        BuildVariableLoad(states, proxy->var(), expr->expression()->id(), pair,
+        BuildVariableLoad(proxy->var(), expr->expression()->id(), states, pair,
                           OutputFrameStateCombine::Push(), NOT_CONTEXTUAL);
   } else {
     VisitForValue(expr->expression());
     operand = environment()->Pop();
   }
   Node* value = NewNode(javascript()->TypeOf(), operand);
   ast_context()->ProduceValue(value);
 }
 
 
@@ skipping 155 matching lines @@
 
   // Allocate and initialize a new arguments object.
   Node* callee = GetFunctionClosure();
   const Operator* op = javascript()->CallRuntime(Runtime::kNewArguments, 1);
   Node* object = NewNode(op, callee);
 
   // Assign the object to the arguments variable.
   DCHECK(arguments->IsContextSlot() || arguments->IsStackAllocated());
   // This should never lazy deopt, so it is fine to send invalid bailout id.
   FrameStateBeforeAndAfter states(this, BailoutId::None());
-  BuildVariableAssignment(states, arguments, object, Token::ASSIGN,
-                          BailoutId::None());
+  BuildVariableAssignment(arguments, object, Token::ASSIGN, BailoutId::None(),
+                          states);
 
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildRestArgumentsArray(Variable* rest, int index) {
   if (rest == NULL) return NULL;
 
   DCHECK(index >= 0);
   const Operator* op = javascript()->CallRuntime(Runtime::kNewRestParamSlow, 1);
   Node* object = NewNode(op, jsgraph()->SmiConstant(index));
 
   // Assign the object to the rest array
   DCHECK(rest->IsContextSlot() || rest->IsStackAllocated());
   // This should never lazy deopt, so it is fine to send invalid bailout id.
   FrameStateBeforeAndAfter states(this, BailoutId::None());
-  BuildVariableAssignment(states, rest, object, Token::ASSIGN,
-                          BailoutId::None());
+  BuildVariableAssignment(rest, object, Token::ASSIGN, BailoutId::None(),
+                          states);
 
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildHoleCheckSilent(Node* value, Node* for_hole,
                                             Node* not_hole) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   Node* check = NewNode(javascript()->StrictEqual(), value, the_hole);
   return NewNode(common()->Select(kMachAnyTagged, BranchHint::kFalse), check,
@@ skipping 28 matching lines @@
   prototype_check.Then();
   Node* error = BuildThrowStaticPrototypeError(bailout_id);
   environment()->Push(error);
   prototype_check.Else();
   environment()->Push(name);
   prototype_check.End();
   return environment()->Pop();
 }
 
 
-Node* AstGraphBuilder::BuildVariableLoad(FrameStateBeforeAndAfter& states,
-                                         Variable* variable,
+Node* AstGraphBuilder::BuildVariableLoad(Variable* variable,
                                          BailoutId bailout_id,
+                                         FrameStateBeforeAndAfter& states,
                                          const VectorSlotPair& feedback,
                                          OutputFrameStateCombine combine,
                                          ContextualMode contextual_mode) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   VariableMode mode = variable->mode();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       Handle<Name> name = variable->name();
@@ skipping 38 matching lines @@
         Node* undefined = jsgraph()->UndefinedConstant();
         value = BuildHoleCheckSilent(value, undefined, value);
       } else if (mode == LET || mode == CONST) {
         // Perform check for uninitialized let/const variables.
         value = BuildHoleCheckThrow(value, variable, value, bailout_id);
       }
       return value;
     }
     case Variable::LOOKUP: {
       // Dynamic lookup of context variable (anywhere in the chain).
-      Node* name = jsgraph()->Constant(variable->name());
-      Runtime::FunctionId function_id =
-          (contextual_mode == CONTEXTUAL)
-              ? Runtime::kLoadLookupSlot
-              : Runtime::kLoadLookupSlotNoReferenceError;
-      const Operator* op = javascript()->CallRuntime(function_id, 2);
-      Node* pair = NewNode(op, current_context(), name);
-      PrepareFrameState(pair, bailout_id, OutputFrameStateCombine::Push(1));
-      return NewNode(common()->Projection(0), pair);
+      if (mode == DYNAMIC_GLOBAL) {
+        // Try to optimize known global when not shadowed.
+        if (Node* fast_value = TryVariableLoadDynamicGlobal(
+                variable, bailout_id, states, feedback, combine,
+                contextual_mode)) {
+          return fast_value;
+        }
+      } else if (mode == DYNAMIC_LOCAL) {
+        // Try to optimize known local when not shadowed.
+        // TODO(mstarzinger): Implement TryVariableLoadDynamicLocal().
+      }
+      return BuildDynamicVariableLoad(variable, bailout_id, contextual_mode);
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildVariableDelete(Variable* variable,
                                            BailoutId bailout_id,
                                            OutputFrameStateCombine combine) {
@@ skipping 21 matching lines @@
       PrepareFrameState(result, bailout_id, combine);
       return result;
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildVariableAssignment(
-    FrameStateBeforeAndAfter& states, Variable* variable, Node* value,
-    Token::Value op, BailoutId bailout_id, OutputFrameStateCombine combine) {
+    Variable* variable, Node* value, Token::Value op, BailoutId bailout_id,
+    FrameStateBeforeAndAfter& states, OutputFrameStateCombine combine) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   VariableMode mode = variable->mode();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       Handle<Name> name = variable->name();
       Node* store =
           BuildNamedStore(global, name, value, TypeFeedbackId::None());
       states.AddToNode(store, bailout_id, combine);
@@ skipping 84 matching lines @@
       Node* store = NewNode(op, value, current_context(), name, language);
       PrepareFrameState(store, bailout_id, combine);
       return store;
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
+Node* AstGraphBuilder::TryVariableLoadDynamicGlobal(

[titzer, 2015/05/27 14:06:21]

The ordering of the words is kind of mixed up here. Not sure what the best name
is, but I find this one confusing.

[Michael Starzinger, 2015/05/27 14:10:28]

Done. True, the name is confusing, changed it to TryDynamicGlobalVariableLoad
which follows the naming convention of the rest of the methods.

+    Variable* variable, BailoutId bailout_id, FrameStateBeforeAndAfter& states,
+    const VectorSlotPair& feedback, OutputFrameStateCombine combine,
+    ContextualMode contextual_mode) {
+  DCHECK_EQ(DYNAMIC_GLOBAL, variable->mode());
+
+  // Determine which contexts need to be checked for extension objects that
+  // might shadow the optimistic declaration.
+  int current_depth = 0;
+  ZoneVector<int> check_depths(local_zone());
+  for (Scope* s = current_scope(); s != nullptr; s = s->outer_scope()) {
+    if (s->num_heap_slots() <= 0) continue;
+    check_depths.push_back(current_depth++);
+  }
+
+  // Impose artificial upper bound on the number of checks.
+  const int kMaxContextExtensionObjectChecks = 6;
+  if (check_depths.size() > kMaxContextExtensionObjectChecks) return nullptr;
+
+  // We are using two blocks to model fast and slow cases.
+  BlockBuilder fast_block(this);
+  BlockBuilder slow_block(this);
+  environment()->Push(jsgraph()->TheHoleConstant());
+  slow_block.BeginBlock();
+  environment()->Pop();
+  fast_block.BeginBlock();
+
+  // Perform checks whether the fast mode applies, by looking whether for any
+  // extension object which might shadow the optimistic declaration.
+  for (int depth : check_depths) {
+    Node* load = NewNode(
+        javascript()->LoadContext(depth, Context::EXTENSION_INDEX, false),
+        current_context());
+    Node* check =
+        NewNode(javascript()->CallRuntime(Runtime::kInlineIsSmi, 1), load);
+    fast_block.BreakUnless(check, BranchHint::kTrue);
+  }
+
+  // Fast case, because variable is not shadowed. Perform global object load.
+  Node* fast = BuildGlobalVariableLoad(variable, bailout_id, states, feedback,
+                                       combine, contextual_mode);
+  environment()->Push(fast);
+  slow_block.Break();
+  environment()->Pop();
+  fast_block.EndBlock();
+
+  // Slow case, because variable potentially shadowed. Perform dynamic lookup.
+  Node* slow = BuildDynamicVariableLoad(variable, bailout_id, contextual_mode);
+  environment()->Push(slow);
+  slow_block.EndBlock();
+
+  return environment()->Pop();
+}
+
+
+Node* AstGraphBuilder::BuildGlobalVariableLoad(Variable* variable,
+                                               BailoutId bailout_id,
+                                               FrameStateBeforeAndAfter& states,
+                                               const VectorSlotPair& feedback,
+                                               OutputFrameStateCombine combine,
+                                               ContextualMode contextual_mode) {
+  Node* global = BuildLoadGlobalObject();
+  Handle<Name> name = variable->name();
+  Node* node = BuildNamedLoad(global, name, feedback, contextual_mode);
+  states.AddToNode(node, bailout_id, combine);
+  return node;
+}
+
+
+Node* AstGraphBuilder::BuildDynamicVariableLoad(
+    Variable* variable, BailoutId bailout_id, ContextualMode contextual_mode) {
+  Node* name = jsgraph()->Constant(variable->name());
+  Runtime::FunctionId function_id =
+      (contextual_mode == CONTEXTUAL)
+          ? Runtime::kLoadLookupSlot
+          : Runtime::kLoadLookupSlotNoReferenceError;
+  const Operator* op = javascript()->CallRuntime(function_id, 2);
+  Node* pair = NewNode(op, current_context(), name);
+  PrepareFrameState(pair, bailout_id, OutputFrameStateCombine::Push(1));
+  return NewNode(common()->Projection(0), pair);
+}
+
+
 static inline Node* Record(JSTypeFeedbackTable* js_type_feedback, Node* node,
                            FeedbackVectorICSlot slot) {
   if (js_type_feedback) {
     js_type_feedback->Record(node, slot);
   }
   return node;
 }
 
 
 static inline Node* Record(JSTypeFeedbackTable* js_type_feedback, Node* node,
@@ skipping 557 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