[turbofan] Revive the VectorSlotPair and also put feedback on JSCallFunction.

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 1347 matching lines @@
       PrepareFrameState(value, stmt->FilterId(),
                         OutputFrameStateCombine::Push());
       IfBuilder test_value(this);
       Node* test_value_cond = NewNode(javascript()->StrictEqual(), value,
                                       jsgraph()->UndefinedConstant());
       test_value.If(test_value_cond, BranchHint::kFalse);
       test_value.Then();
       test_value.Else();
       {
         // Bind value and do loop body.
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(stmt->EachFeedbackSlot());
-        VisitForInAssignment(stmt->each(), value, slot, stmt->AssignmentId());
+        VectorSlotPair feedback =
+            CreateVectorSlotPair(stmt->EachFeedbackSlot());
+        VisitForInAssignment(stmt->each(), value, feedback,
+                             stmt->AssignmentId());
         VisitIterationBody(stmt, &for_loop);
       }
       test_value.End();
       index = environment()->Peek(0);
       for_loop.EndBody();
 
       // Increment counter and continue.
       index = NewNode(javascript()->ForInStep(), index);
       environment()->Poke(0, index);
     }
@@ skipping 223 matching lines @@
     if (property->is_static() && property->is_computed_name()) {
       Node* check = BuildThrowIfStaticPrototype(environment()->Pop(),
                                                 expr->GetIdForProperty(i));
       environment()->Push(check);
     }
 
     VisitForValue(property->value());
     Node* value = environment()->Pop();
     Node* key = environment()->Pop();
     Node* receiver = environment()->Pop();
-    ResolvedFeedbackSlot slot = ResolveFeedbackSlot(
+    VectorSlotPair feedback = CreateVectorSlotPair(
         expr->SlotForHomeObject(property->value(), &store_slot_index));
-    BuildSetHomeObject(value, receiver, property->value(), slot);
+    BuildSetHomeObject(value, receiver, property->value(), feedback);
 
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
       case ObjectLiteral::Property::PROTOTYPE:
         UNREACHABLE();
       case ObjectLiteral::Property::COMPUTED: {
         const Operator* op =
             javascript()->CallRuntime(Runtime::kDefineClassMethod, 3);
         NewNode(op, receiver, key, value);
@@ skipping 19 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());
-    ResolvedFeedbackSlot slot = ResolveFeedbackSlot(
+    VectorSlotPair feedback = CreateVectorSlotPair(
         FLAG_vector_stores ? expr->GetNthSlot(store_slot_index++)
                            : FeedbackVectorICSlot::Invalid());
-    BuildVariableAssignment(var, literal, Token::INIT_CONST, slot,
+    BuildVariableAssignment(var, literal, Token::INIT_CONST, feedback,
                             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) {
-  ResolvedFeedbackSlot slot = ResolveFeedbackSlot(expr->VariableFeedbackSlot());
+  VectorSlotPair pair = CreateVectorSlotPair(expr->VariableFeedbackSlot());
   FrameStateBeforeAndAfter states(this, BeforeId(expr));
-  Node* value = BuildVariableLoad(expr->var(), expr->id(), states, slot,
+  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 51 matching lines @@
       // Fall through.
       case ObjectLiteral::Property::COMPUTED: {
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (key->value()->IsInternalizedString()) {
           if (property->emit_store()) {
             VisitForValue(property->value());
             FrameStateBeforeAndAfter states(this, property->value()->id());
             Node* value = environment()->Pop();
             Handle<Name> name = key->AsPropertyName();
-            ResolvedFeedbackSlot slot =
+            VectorSlotPair feedback =
                 FLAG_vector_stores
-                    ? ResolveFeedbackSlot(expr->GetNthSlot(store_slot_index++))
-                    : ResolvedFeedbackSlot();
-            Node* store = BuildNamedStore(literal, name, value, slot,
+                    ? CreateVectorSlotPair(expr->GetNthSlot(store_slot_index++))
+                    : VectorSlotPair();
+            Node* store = BuildNamedStore(literal, name, value, feedback,
                                           TypeFeedbackId::None());
             states.AddToNode(store, key->id(),
                              OutputFrameStateCombine::Ignore());
-            ResolvedFeedbackSlot home_slot = ResolveFeedbackSlot(
+            VectorSlotPair home_feedback = CreateVectorSlotPair(
                 expr->SlotForHomeObject(property->value(), &store_slot_index));
-            BuildSetHomeObject(value, literal, property->value(), home_slot);
+            BuildSetHomeObject(value, literal, property->value(),
+                               home_feedback);
           } else {
             VisitForEffect(property->value());
           }
           break;
         }
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->key());
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* key = environment()->Pop();
         Node* receiver = environment()->Pop();
         if (property->emit_store()) {
           Node* language = jsgraph()->Constant(SLOPPY);
           const Operator* op =
               javascript()->CallRuntime(Runtime::kSetProperty, 4);
           Node* set_property = NewNode(op, receiver, key, value, language);
           // SetProperty should not lazy deopt on an object literal.
           PrepareFrameState(set_property, BailoutId::None());
-          ResolvedFeedbackSlot home_slot = ResolveFeedbackSlot(
+          VectorSlotPair home_feedback = CreateVectorSlotPair(
               expr->SlotForHomeObject(property->value(), &store_slot_index));
-          BuildSetHomeObject(value, receiver, property->value(), home_slot);
+          BuildSetHomeObject(value, receiver, property->value(), home_feedback);
         }
         break;
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* receiver = environment()->Pop();
         DCHECK(property->emit_store());
         const Operator* op =
@@ skipping 15 matching lines @@
         break;
     }
   }
 
   // Create nodes to define accessors, using only a single call to the runtime
   // for each pair of corresponding getters and setters.
   for (AccessorTable::Iterator it = accessor_table.begin();
        it != accessor_table.end(); ++it) {
     VisitForValue(it->first);
     VisitForValueOrNull(it->second->getter);
-    ResolvedFeedbackSlot slot_getter = ResolveFeedbackSlot(
+    VectorSlotPair feedback_getter = CreateVectorSlotPair(
         expr->SlotForHomeObject(it->second->getter, &store_slot_index));
     BuildSetHomeObject(environment()->Top(), literal, it->second->getter,
-                       slot_getter);
+                       feedback_getter);
     VisitForValueOrNull(it->second->setter);
-    ResolvedFeedbackSlot slot_setter = ResolveFeedbackSlot(
+    VectorSlotPair feedback_setter = CreateVectorSlotPair(
         expr->SlotForHomeObject(it->second->getter, &store_slot_index));
     BuildSetHomeObject(environment()->Top(), literal, it->second->setter,
-                       slot_setter);
+                       feedback_setter);
     Node* setter = environment()->Pop();
     Node* getter = environment()->Pop();
     Node* name = environment()->Pop();
     Node* attr = jsgraph()->Constant(NONE);
     const Operator* op =
         javascript()->CallRuntime(Runtime::kDefineAccessorPropertyUnchecked, 5);
     Node* call = NewNode(op, literal, name, getter, setter, attr);
     // This should not lazy deopt on a new literal.
     PrepareFrameState(call, BailoutId::None());
   }
@@ skipping 24 matching lines @@
 
     environment()->Push(literal);  // Duplicate receiver.
     VisitForValue(property->key());
     Node* name = BuildToName(environment()->Pop(),
                              expr->GetIdForProperty(property_index));
     environment()->Push(name);
     VisitForValue(property->value());
     Node* value = environment()->Pop();
     Node* key = environment()->Pop();
     Node* receiver = environment()->Pop();
-    ResolvedFeedbackSlot slot = ResolveFeedbackSlot(
+    VectorSlotPair feedback = CreateVectorSlotPair(
         expr->SlotForHomeObject(property->value(), &store_slot_index));
-    BuildSetHomeObject(value, receiver, property->value(), slot);
+    BuildSetHomeObject(value, receiver, property->value(), feedback);
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
       case ObjectLiteral::Property::COMPUTED:
       case ObjectLiteral::Property::MATERIALIZED_LITERAL: {
         Node* attr = jsgraph()->Constant(NONE);
         const Operator* op =
             javascript()->CallRuntime(Runtime::kDefineDataPropertyUnchecked, 4);
         Node* call = NewNode(op, receiver, key, value, attr);
         PrepareFrameState(call, BailoutId::None());
         break;
@@ skipping 61 matching lines @@
   for (; array_index < expr->values()->length(); array_index++) {
     Expression* subexpr = expr->values()->at(array_index);
     if (subexpr->IsSpread()) break;
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
 
     VisitForValue(subexpr);
     {
       FrameStateBeforeAndAfter states(this, subexpr->id());
       Node* value = environment()->Pop();
       Node* index = jsgraph()->Constant(array_index);
-      Node* store =
-          BuildKeyedStore(literal, index, value, ResolvedFeedbackSlot(),
-                          TypeFeedbackId::None());
+      Node* store = BuildKeyedStore(literal, index, value, VectorSlotPair(),
+                                    TypeFeedbackId::None());
       states.AddToNode(store, expr->GetIdForElement(array_index),
                        OutputFrameStateCombine::Ignore());
     }
   }
 
   // In case the array literal contains spread expressions it has two parts. The
   // first part is  the "static" array which has a literal index is handled
   // above. The second part is the part after the first spread expression
   // (inclusive) and these elements gets appended to the array. Note that the
   // number elements an iterable produces is unknown ahead of time.
@@ skipping 23 matching lines @@
 
     PrepareFrameState(result, expr->GetIdForElement(array_index));
     environment()->Push(result);
   }
 
   ast_context()->ProduceValue(environment()->Pop());
 }
 
 
 void AstGraphBuilder::VisitForInAssignment(Expression* expr, Node* value,
-                                           const ResolvedFeedbackSlot& slot,
+                                           const VectorSlotPair& feedback,
                                            BailoutId bailout_id) {
   DCHECK(expr->IsValidReferenceExpression());
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->AsProperty();
   LhsKind assign_type = Property::GetAssignType(property);
 
   // Evaluate LHS expression and store the value.
   switch (assign_type) {
     case VARIABLE: {
       Variable* var = expr->AsVariableProxy()->var();
       FrameStateBeforeAndAfter states(this, BailoutId::None());
-      BuildVariableAssignment(var, value, Token::ASSIGN, slot, bailout_id,
+      BuildVariableAssignment(var, value, Token::ASSIGN, feedback, 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 =
-          BuildNamedStore(object, name, value, slot, TypeFeedbackId::None());
+      Node* store = BuildNamedStore(object, name, value, feedback,
+                                    TypeFeedbackId::None());
       states.AddToNode(store, bailout_id, OutputFrameStateCombine::Ignore());
       break;
     }
     case KEYED_PROPERTY: {
       environment()->Push(value);
       VisitForValue(property->obj());
       VisitForValue(property->key());
       FrameStateBeforeAndAfter states(this, property->key()->id());
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
       value = environment()->Pop();
       Node* store =
-          BuildKeyedStore(object, key, value, slot, TypeFeedbackId::None());
+          BuildKeyedStore(object, key, value, feedback, TypeFeedbackId::None());
       states.AddToNode(store, bailout_id, OutputFrameStateCombine::Ignore());
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       environment()->Push(value);
       VisitForValue(property->obj()->AsSuperPropertyReference()->this_var());
       VisitForValue(property->obj()->AsSuperPropertyReference()->home_object());
       FrameStateBeforeAndAfter states(this, property->obj()->id());
       Node* home_object = environment()->Pop();
       Node* receiver = environment()->Pop();
@@ skipping 61 matching lines @@
   }
 
   BailoutId before_store_id = BailoutId::None();
   // Evaluate the value and potentially handle compound assignments by loading
   // 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();
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(proxy->VariableFeedbackSlot());
+        VectorSlotPair pair =
+            CreateVectorSlotPair(proxy->VariableFeedbackSlot());
         FrameStateBeforeAndAfter states(this, BeforeId(proxy));
         old_value =
-            BuildVariableLoad(proxy->var(), expr->target()->id(), states, slot,
+            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();
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(property->PropertyFeedbackSlot());
+        VectorSlotPair pair =
+            CreateVectorSlotPair(property->PropertyFeedbackSlot());
         FrameStateBeforeAndAfter states(this, property->obj()->id());
-        old_value = BuildNamedLoad(object, name, slot);
+        old_value = BuildNamedLoad(object, name, pair);
         states.AddToNode(old_value, property->LoadId(),
                          OutputFrameStateCombine::Push());
         break;
       }
       case KEYED_PROPERTY: {
         Node* key = environment()->Top();
         Node* object = environment()->Peek(1);
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(property->PropertyFeedbackSlot());
+        VectorSlotPair pair =
+            CreateVectorSlotPair(property->PropertyFeedbackSlot());
         FrameStateBeforeAndAfter states(this, property->key()->id());
-        old_value = BuildKeyedLoad(object, key, slot);
+        old_value = BuildKeyedLoad(object, key, pair);
         states.AddToNode(old_value, property->LoadId(),
                          OutputFrameStateCombine::Push());
         break;
       }
       case NAMED_SUPER_PROPERTY: {
         Node* home_object = environment()->Top();
         Node* receiver = environment()->Peek(1);
         Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(property->PropertyFeedbackSlot());
+        VectorSlotPair pair =
+            CreateVectorSlotPair(property->PropertyFeedbackSlot());
         FrameStateBeforeAndAfter states(this, property->obj()->id());
-        old_value = BuildNamedSuperLoad(receiver, home_object, name, slot);
+        old_value = BuildNamedSuperLoad(receiver, home_object, name, pair);
         states.AddToNode(old_value, property->LoadId(),
                          OutputFrameStateCombine::Push());
         break;
       }
       case KEYED_SUPER_PROPERTY: {
         Node* key = environment()->Top();
         Node* home_object = environment()->Peek(1);
         Node* receiver = environment()->Peek(2);
-        ResolvedFeedbackSlot slot =
-            ResolveFeedbackSlot(property->PropertyFeedbackSlot());
+        VectorSlotPair pair =
+            CreateVectorSlotPair(property->PropertyFeedbackSlot());
         FrameStateBeforeAndAfter states(this, property->key()->id());
-        old_value = BuildKeyedSuperLoad(receiver, home_object, key, slot);
+        old_value = BuildKeyedSuperLoad(receiver, home_object, key, pair);
         states.AddToNode(old_value, property->LoadId(),
                          OutputFrameStateCombine::Push());
         break;
       }
     }
     environment()->Push(old_value);
     VisitForValue(expr->value());
     Node* value;
     {
       FrameStateBeforeAndAfter states(this, expr->value()->id());
@@ skipping 10 matching lines @@
   } else {
     VisitForValue(expr->value());
     if (needs_frame_state_before) {
       before_store_id = expr->value()->id();
     }
   }
 
   FrameStateBeforeAndAfter store_states(this, before_store_id);
   // Store the value.
   Node* value = environment()->Pop();
-  ResolvedFeedbackSlot slot = ResolveFeedbackSlot(expr->AssignmentSlot());
+  VectorSlotPair feedback = CreateVectorSlotPair(expr->AssignmentSlot());
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->target()->AsVariableProxy()->var();
-      BuildVariableAssignment(variable, value, expr->op(), slot, expr->id(),
+      BuildVariableAssignment(variable, value, expr->op(), feedback, 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, slot,
+      Node* store = BuildNamedStore(object, name, value, feedback,
                                     expr->AssignmentFeedbackId());
       store_states.AddToNode(store, expr->id(),
                              ast_context()->GetStateCombine());
       break;
     }
     case KEYED_PROPERTY: {
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
-      Node* store = BuildKeyedStore(object, key, value, slot,
+      Node* store = BuildKeyedStore(object, key, value, feedback,
                                     expr->AssignmentFeedbackId());
       store_states.AddToNode(store, expr->id(),
                              ast_context()->GetStateCombine());
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       Node* home_object = environment()->Pop();
       Node* receiver = environment()->Pop();
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
       Node* store = BuildNamedSuperStore(receiver, home_object, name, value,
@@ skipping 29 matching lines @@
   VisitForValue(expr->exception());
   Node* exception = environment()->Pop();
   Node* value = BuildThrowError(exception, expr->id());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitProperty(Property* expr) {
   Node* value = nullptr;
   LhsKind property_kind = Property::GetAssignType(expr);
-  ResolvedFeedbackSlot slot = ResolveFeedbackSlot(expr->PropertyFeedbackSlot());
+  VectorSlotPair pair = CreateVectorSlotPair(expr->PropertyFeedbackSlot());
   switch (property_kind) {
     case VARIABLE:
       UNREACHABLE();
       break;
     case NAMED_PROPERTY: {
       VisitForValue(expr->obj());
       FrameStateBeforeAndAfter states(this, expr->obj()->id());
       Node* object = environment()->Pop();
       Handle<Name> name = expr->key()->AsLiteral()->AsPropertyName();
-      value = BuildNamedLoad(object, name, slot);
+      value = BuildNamedLoad(object, name, pair);
       states.AddToNode(value, expr->id(), ast_context()->GetStateCombine());
       break;
     }
     case KEYED_PROPERTY: {
       VisitForValue(expr->obj());
       VisitForValue(expr->key());
       FrameStateBeforeAndAfter states(this, expr->key()->id());
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
-      value = BuildKeyedLoad(object, key, slot);
+      value = BuildKeyedLoad(object, key, pair);
       states.AddToNode(value, expr->id(), ast_context()->GetStateCombine());
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       VisitForValue(expr->obj()->AsSuperPropertyReference()->this_var());
       VisitForValue(expr->obj()->AsSuperPropertyReference()->home_object());
       FrameStateBeforeAndAfter states(this, expr->obj()->id());
       Node* home_object = environment()->Pop();
       Node* receiver = environment()->Pop();
       Handle<Name> name = expr->key()->AsLiteral()->AsPropertyName();
-      value = BuildNamedSuperLoad(receiver, home_object, name, slot);
+      value = BuildNamedSuperLoad(receiver, home_object, name, pair);
       states.AddToNode(value, expr->id(), ast_context()->GetStateCombine());
       break;
     }
     case KEYED_SUPER_PROPERTY: {
       VisitForValue(expr->obj()->AsSuperPropertyReference()->this_var());
       VisitForValue(expr->obj()->AsSuperPropertyReference()->home_object());
       VisitForValue(expr->key());
       FrameStateBeforeAndAfter states(this, expr->key()->id());
       Node* key = environment()->Pop();
       Node* home_object = environment()->Pop();
       Node* receiver = environment()->Pop();
-      value = BuildKeyedSuperLoad(receiver, home_object, key, slot);
+      value = BuildKeyedSuperLoad(receiver, home_object, key, pair);
       states.AddToNode(value, expr->id(), ast_context()->GetStateCombine());
       break;
     }
   }
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCall(Call* expr) {
   Expression* callee = 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.
   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();
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(proxy->VariableFeedbackSlot());
+      VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
       FrameStateBeforeAndAfter states(this, BeforeId(proxy));
       callee_value =
           BuildVariableLoad(proxy->var(), expr->expression()->id(), states,
-                            slot, OutputFrameStateCombine::Push());
+                            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);
       Node* pair = NewNode(op, current_context(), name);
       callee_value = NewNode(common()->Projection(0), pair);
       receiver_value = NewNode(common()->Projection(1), pair);
 
       PrepareFrameState(pair, expr->EvalOrLookupId(),
                         OutputFrameStateCombine::Push(2));
       break;
     }
     case Call::PROPERTY_CALL: {
       Property* property = callee->AsProperty();
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(property->PropertyFeedbackSlot());
+      VectorSlotPair pair =
+          CreateVectorSlotPair(property->PropertyFeedbackSlot());
       if (!property->IsSuperAccess()) {
         VisitForValue(property->obj());
         Node* object = environment()->Top();
 
         if (property->key()->IsPropertyName()) {
           FrameStateBeforeAndAfter states(this, property->obj()->id());
           Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
-          callee_value = BuildNamedLoad(object, name, slot);
+          callee_value = BuildNamedLoad(object, name, pair);
           states.AddToNode(callee_value, property->LoadId(),
                            OutputFrameStateCombine::Push());
         } else {
           VisitForValue(property->key());
           FrameStateBeforeAndAfter states(this, property->key()->id());
           Node* key = environment()->Pop();
-          callee_value = BuildKeyedLoad(object, key, slot);
+          callee_value = BuildKeyedLoad(object, key, pair);
           states.AddToNode(callee_value, property->LoadId(),
                            OutputFrameStateCombine::Push());
         }
         receiver_value = environment()->Pop();
         // Note that a PROPERTY_CALL requires the receiver to be wrapped into an
         // object for sloppy callees. This could also be modeled explicitly
         // here,
         // thereby obsoleting the need for a flag to the call operator.
         flags = CALL_AS_METHOD;
 
       } else {
         VisitForValue(property->obj()->AsSuperPropertyReference()->this_var());
         VisitForValue(
             property->obj()->AsSuperPropertyReference()->home_object());
         Node* home_object = environment()->Pop();
         receiver_value = environment()->Pop();
         if (property->key()->IsPropertyName()) {
           FrameStateBeforeAndAfter states(this, property->obj()->id());
           Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
           callee_value =
-              BuildNamedSuperLoad(receiver_value, home_object, name, slot);
+              BuildNamedSuperLoad(receiver_value, home_object, name, pair);
           states.AddToNode(callee_value, property->LoadId(),
                            OutputFrameStateCombine::Push());
 
         } else {
           VisitForValue(property->key());
           FrameStateBeforeAndAfter states(this, property->key()->id());
           Node* key = environment()->Pop();
           callee_value =
-              BuildKeyedSuperLoad(receiver_value, home_object, key, slot);
+              BuildKeyedSuperLoad(receiver_value, home_object, key, pair);
           states.AddToNode(callee_value, property->LoadId(),
                            OutputFrameStateCombine::Push());
         }
       }
 
       break;
     }
     case Call::SUPER_CALL:
       // TODO(dslomov): Implement super calls.
       callee_value = jsgraph()->UndefinedConstant();
@@ skipping 38 matching lines @@
     Node* new_callee =
         NewNode(op, callee, source, function, language, position);
     PrepareFrameState(new_callee, expr->EvalOrLookupId(),
                       OutputFrameStateCombine::PokeAt(arg_count + 1));
 
     // Patch callee on the environment.
     environment()->Poke(arg_count + 1, new_callee);
   }
 
   // Create node to perform the function call.
-  const Operator* call =
-      javascript()->CallFunction(args->length() + 2, flags, language_mode());
+  VectorSlotPair feedback = CreateVectorSlotPair(expr->CallFeedbackICSlot());
+  const Operator* call = javascript()->CallFunction(args->length() + 2, flags,
+                                                    language_mode(), feedback);
   Node* value = ProcessArguments(call, args->length() + 2);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallNew(CallNew* expr) {
   VisitForValue(expr->expression());
 
   // Evaluate all arguments to the construct call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the construct call.
   const Operator* call = javascript()->CallConstruct(args->length() + 1);
   Node* value = ProcessArguments(call, args->length() + 1);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallJSRuntime(CallRuntime* expr) {
   Handle<String> name = expr->name();
 
   // The callee and the receiver both have to be pushed onto the operand stack
   // before arguments are being evaluated.
   CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS;
   Node* receiver_value = BuildLoadBuiltinsObject();
-  ResolvedFeedbackSlot slot =
-      ResolveFeedbackSlot(expr->CallRuntimeFeedbackSlot());
+  VectorSlotPair pair = CreateVectorSlotPair(expr->CallRuntimeFeedbackSlot());
   // TODO(jarin): bailout ids for runtime calls.
   FrameStateBeforeAndAfter states(this, BailoutId::None());
-  Node* callee_value = BuildNamedLoad(receiver_value, name, slot);
+  Node* callee_value = BuildNamedLoad(receiver_value, name, pair);
   states.AddToNode(callee_value, BailoutId::None(),
                    OutputFrameStateCombine::Push());
   environment()->Push(callee_value);
   environment()->Push(receiver_value);
 
   // Evaluate all arguments to the JS runtime call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the JS runtime call.
@@ skipping 57 matching lines @@
   // Reserve space for result of postfix operation.
   bool is_postfix = expr->is_postfix() && !ast_context()->IsEffect();
   if (is_postfix) environment()->Push(jsgraph()->UndefinedConstant());
 
   // 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();
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(proxy->VariableFeedbackSlot());
+      VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
       FrameStateBeforeAndAfter states(this, BeforeId(proxy));
       old_value =
           BuildVariableLoad(proxy->var(), expr->expression()->id(), states,
-                            slot, OutputFrameStateCombine::Push());
+                            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();
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(property->PropertyFeedbackSlot());
-      old_value = BuildNamedLoad(object, name, slot);
+      VectorSlotPair pair =
+          CreateVectorSlotPair(property->PropertyFeedbackSlot());
+      old_value = BuildNamedLoad(object, name, pair);
       states.AddToNode(old_value, property->LoadId(),
                        OutputFrameStateCombine::Push());
       stack_depth = 1;
       break;
     }
     case KEYED_PROPERTY: {
       VisitForValue(property->obj());
       VisitForValue(property->key());
       FrameStateBeforeAndAfter states(this, property->key()->id());
       Node* key = environment()->Top();
       Node* object = environment()->Peek(1);
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(property->PropertyFeedbackSlot());
-      old_value = BuildKeyedLoad(object, key, slot);
+      VectorSlotPair pair =
+          CreateVectorSlotPair(property->PropertyFeedbackSlot());
+      old_value = BuildKeyedLoad(object, key, pair);
       states.AddToNode(old_value, property->LoadId(),
                        OutputFrameStateCombine::Push());
       stack_depth = 2;
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       VisitForValue(property->obj()->AsSuperPropertyReference()->this_var());
       VisitForValue(property->obj()->AsSuperPropertyReference()->home_object());
       FrameStateBeforeAndAfter states(this, property->obj()->id());
       Node* home_object = environment()->Top();
       Node* receiver = environment()->Peek(1);
       Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(property->PropertyFeedbackSlot());
-      old_value = BuildNamedSuperLoad(receiver, home_object, name, slot);
+      VectorSlotPair pair =
+          CreateVectorSlotPair(property->PropertyFeedbackSlot());
+      old_value = BuildNamedSuperLoad(receiver, home_object, name, pair);
       states.AddToNode(old_value, property->LoadId(),
                        OutputFrameStateCombine::Push());
       stack_depth = 2;
       break;
     }
     case KEYED_SUPER_PROPERTY: {
       VisitForValue(property->obj()->AsSuperPropertyReference()->this_var());
       VisitForValue(property->obj()->AsSuperPropertyReference()->home_object());
       VisitForValue(property->key());
       FrameStateBeforeAndAfter states(this, property->obj()->id());
       Node* key = environment()->Top();
       Node* home_object = environment()->Peek(1);
       Node* receiver = environment()->Peek(2);
-      ResolvedFeedbackSlot slot =
-          ResolveFeedbackSlot(property->PropertyFeedbackSlot());
-      old_value = BuildKeyedSuperLoad(receiver, home_object, key, slot);
+      VectorSlotPair pair =
+          CreateVectorSlotPair(property->PropertyFeedbackSlot());
+      old_value = BuildKeyedSuperLoad(receiver, home_object, key, pair);
       states.AddToNode(old_value, property->LoadId(),
                        OutputFrameStateCombine::Push());
       stack_depth = 3;
       break;
     }
   }
 
   // Convert old value into a number.
   old_value = NewNode(javascript()->ToNumber(), old_value);
   PrepareFrameState(old_value, expr->ToNumberId(),
@@ skipping 13 matching lines @@
     FrameStateBeforeAndAfter states(this, BailoutId::None());
     value =
         BuildBinaryOp(old_value, jsgraph()->OneConstant(), expr->binary_op());
     // This should never deoptimize because we have converted to number
     // before.
     states.AddToNode(value, BailoutId::None(),
                      OutputFrameStateCombine::Ignore());
   }
 
   // Store the value.
-  ResolvedFeedbackSlot slot = ResolveFeedbackSlot(expr->CountSlot());
+  VectorSlotPair feedback = CreateVectorSlotPair(expr->CountSlot());
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->expression()->AsVariableProxy()->var();
       environment()->Push(value);
-      BuildVariableAssignment(variable, value, expr->op(), slot,
+      BuildVariableAssignment(variable, value, expr->op(), feedback,
                               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, slot,
+      Node* store = BuildNamedStore(object, name, value, feedback,
                                     expr->CountStoreFeedbackId());
       environment()->Push(value);
       store_states.AddToNode(store, expr->AssignmentId(),
                              OutputFrameStateCombine::Ignore());
       environment()->Pop();
       break;
     }
     case KEYED_PROPERTY: {
       Node* key = environment()->Pop();
       Node* object = environment()->Pop();
-      Node* store = BuildKeyedStore(object, key, value, slot,
+      Node* store = BuildKeyedStore(object, key, value, feedback,
                                     expr->CountStoreFeedbackId());
       environment()->Push(value);
       store_states.AddToNode(store, expr->AssignmentId(),
                              OutputFrameStateCombine::Ignore());
       environment()->Pop();
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       Node* home_object = environment()->Pop();
       Node* receiver = environment()->Pop();
@@ skipping 202 matching lines @@
   ast_context()->ProduceValue(value);
 }
 
 
 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();
-    ResolvedFeedbackSlot slot =
-        ResolveFeedbackSlot(proxy->VariableFeedbackSlot());
+    VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
     FrameStateBeforeAndAfter states(this, BeforeId(proxy));
     operand =
-        BuildVariableLoad(proxy->var(), expr->expression()->id(), states, slot,
+        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 40 matching lines @@
   compare_if.End();
   ast_context()->ReplaceValue();
 }
 
 
 LanguageMode AstGraphBuilder::language_mode() const {
   return info()->language_mode();
 }
 
 
-ResolvedFeedbackSlot AstGraphBuilder::ResolveFeedbackSlot(
+VectorSlotPair AstGraphBuilder::CreateVectorSlotPair(
     FeedbackVectorICSlot slot) const {
-  return ResolvedFeedbackSlot(handle(info()->shared_info()->feedback_vector()),
-                              slot);
+  return VectorSlotPair(handle(info()->shared_info()->feedback_vector()), slot);
 }
 
 
 uint32_t AstGraphBuilder::ComputeBitsetForDynamicGlobal(Variable* variable) {
   DCHECK_EQ(DYNAMIC_GLOBAL, variable->mode());
   bool found_eval_scope = false;
   EnumSet<int, uint32_t> check_depths;
   for (Scope* s = current_scope(); s != nullptr; s = s->outer_scope()) {
     if (s->num_heap_slots() <= 0) continue;
     // TODO(mstarzinger): If we have reached an eval scope, we check all
@@ skipping 130 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());
-  ResolvedFeedbackSlot slot;
-  BuildVariableAssignment(arguments, object, Token::ASSIGN, slot,
+  VectorSlotPair feedback;
+  BuildVariableAssignment(arguments, object, Token::ASSIGN, feedback,
                           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, 2);
   Node* object = NewNode(op, jsgraph()->SmiConstant(index),
                          jsgraph()->SmiConstant(language_mode()));
 
   // 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());
-  ResolvedFeedbackSlot slot;
-  BuildVariableAssignment(rest, object, Token::ASSIGN, slot, BailoutId::None(),
-                          states);
+  VectorSlotPair feedback;
+  BuildVariableAssignment(rest, object, Token::ASSIGN, feedback,
+                          BailoutId::None(), states);
 
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildThisFunctionVar(Variable* this_function_var) {
   if (this_function_var == nullptr) return nullptr;
 
   Node* this_function = GetFunctionClosure();
   FrameStateBeforeAndAfter states(this, BailoutId::None());
-  ResolvedFeedbackSlot slot;
+  VectorSlotPair feedback;
   BuildVariableAssignment(this_function_var, this_function, Token::INIT_CONST,
-                          slot, BailoutId::None(), states);
+                          feedback, BailoutId::None(), states);
   return this_function;
 }
 
 
 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,
                  for_hole, not_hole);
@@ skipping 30 matching lines @@
   prototype_check.Else();
   environment()->Push(name);
   prototype_check.End();
   return environment()->Pop();
 }
 
 
 Node* AstGraphBuilder::BuildVariableLoad(Variable* variable,
                                          BailoutId bailout_id,
                                          FrameStateBeforeAndAfter& states,
-                                         const ResolvedFeedbackSlot& feedback,
+                                         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();
       Node* value = BuildNamedLoad(global, name, feedback, contextual_mode);
@@ skipping 114 matching lines @@
       return result;
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Node* AstGraphBuilder::BuildVariableAssignment(
     Variable* variable, Node* value, Token::Value op,
-    const ResolvedFeedbackSlot& slot, BailoutId bailout_id,
+    const VectorSlotPair& feedback, 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, slot, TypeFeedbackId::None());
+      Node* store = BuildNamedStore(global, name, value, feedback,
+                                    TypeFeedbackId::None());
       states.AddToNode(store, bailout_id, combine);
       return store;
     }
     case Variable::PARAMETER:
     case Variable::LOCAL:
       // Local var, const, or let variable.
       if (mode == CONST_LEGACY && op == Token::INIT_CONST_LEGACY) {
         // Perform an initialization check for legacy const variables.
         Node* current = environment()->Lookup(variable);
         if (current->op() != the_hole->op()) {
@@ skipping 94 matching lines @@
 static inline Node* Record(JSTypeFeedbackTable* js_type_feedback, Node* node,
                            TypeFeedbackId id) {
   if (js_type_feedback) {
     js_type_feedback->Record(node, id);
   }
   return node;
 }
 
 
 Node* AstGraphBuilder::BuildKeyedLoad(Node* object, Node* key,
-                                      const ResolvedFeedbackSlot& feedback) {
+                                      const VectorSlotPair& feedback) {
   const Operator* op = javascript()->LoadProperty(feedback);
   return Record(js_type_feedback_,
                 NewNode(op, object, key, GetFeedbackVector()), feedback.slot());
 }
 
 
 Node* AstGraphBuilder::BuildNamedLoad(Node* object, Handle<Name> name,
-                                      const ResolvedFeedbackSlot& feedback,
+                                      const VectorSlotPair& feedback,
                                       ContextualMode mode) {
   const Operator* op =
       javascript()->LoadNamed(MakeUnique(name), feedback, mode);
   return Record(js_type_feedback_, NewNode(op, object, GetFeedbackVector()),
                 feedback.slot());
 }
 
 
 Node* AstGraphBuilder::BuildKeyedStore(Node* object, Node* key, Node* value,
-                                       const ResolvedFeedbackSlot& feedback,
+                                       const VectorSlotPair& feedback,
                                        TypeFeedbackId id) {
   const Operator* op = javascript()->StoreProperty(language_mode(), feedback);
   return Record(js_type_feedback_, NewNode(op, object, key, value), id);
 }
 
 
 Node* AstGraphBuilder::BuildNamedStore(Node* object, Handle<Name> name,
                                        Node* value,
-                                       const ResolvedFeedbackSlot& feedback,
+                                       const VectorSlotPair& feedback,
                                        TypeFeedbackId id) {
   const Operator* op =
       javascript()->StoreNamed(language_mode(), MakeUnique(name), feedback);
   return Record(js_type_feedback_, NewNode(op, object, value), id);
 }
 
 
-Node* AstGraphBuilder::BuildNamedSuperLoad(
-    Node* receiver, Node* home_object, Handle<Name> name,
-    const ResolvedFeedbackSlot& feedback) {
+Node* AstGraphBuilder::BuildNamedSuperLoad(Node* receiver, Node* home_object,
+                                           Handle<Name> name,
+                                           const VectorSlotPair& feedback) {
   Node* name_node = jsgraph()->Constant(name);
   const Operator* op = javascript()->CallRuntime(Runtime::kLoadFromSuper, 3);
   Node* value = NewNode(op, receiver, home_object, name_node);
   return Record(js_type_feedback_, value, feedback.slot());
 }
 
 
-Node* AstGraphBuilder::BuildKeyedSuperLoad(
-    Node* receiver, Node* home_object, Node* key,
-    const ResolvedFeedbackSlot& feedback) {
+Node* AstGraphBuilder::BuildKeyedSuperLoad(Node* receiver, Node* home_object,
+                                           Node* key,
+                                           const VectorSlotPair& feedback) {
   const Operator* op =
       javascript()->CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
   Node* value = NewNode(op, receiver, home_object, key);
   return Record(js_type_feedback_, value, feedback.slot());
 }
 
 
 Node* AstGraphBuilder::BuildKeyedSuperStore(Node* receiver, Node* home_object,
                                             Node* key, Node* value,
                                             TypeFeedbackId id) {
@@ skipping 108 matching lines @@
 
 Node* AstGraphBuilder::BuildToObject(Node* input, BailoutId bailout_id) {
   Node* object = NewNode(javascript()->ToObject(), input);
   PrepareFrameState(object, bailout_id, OutputFrameStateCombine::Push());
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildSetHomeObject(Node* value, Node* home_object,
                                           Expression* expr,
-                                          const ResolvedFeedbackSlot& slot) {
+                                          const VectorSlotPair& feedback) {
   if (!FunctionLiteral::NeedsHomeObject(expr)) return value;
   Handle<Name> name = isolate()->factory()->home_object_symbol();
   FrameStateBeforeAndAfter states(this, BailoutId::None());
-  Node* store =
-      BuildNamedStore(value, name, home_object, slot, TypeFeedbackId::None());
+  Node* store = BuildNamedStore(value, name, home_object, feedback,
+                                TypeFeedbackId::None());
   states.AddToNode(store, BailoutId::None(), OutputFrameStateCombine::Ignore());
   return store;
 }
 
 
 Node* AstGraphBuilder::BuildThrowError(Node* exception, BailoutId bailout_id) {
   const Operator* op = javascript()->CallRuntime(Runtime::kThrow, 1);
   Node* call = NewNode(op, exception);
   PrepareFrameState(call, bailout_id);
   Node* control = NewNode(common()->Throw(), call);
@@ skipping 428 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