[turbofan] Remember types for deoptimization during simplified lowering.

src/compiler/state-values-utils.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/state-values-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 155 matching lines @@
   } else {
     return GetValuesNodeFromCache(&(buffer->front()), count);
   }
 }
 
 
 Node* StateValuesCache::GetNodeForValues(Node** values, size_t count) {
 #if DEBUG
   for (size_t i = 0; i < count; i++) {
     DCHECK_NE(values[i]->opcode(), IrOpcode::kStateValues);
+    DCHECK_NE(values[i]->opcode(), IrOpcode::kTypedStateValues);
   }
 #endif
   if (count == 0) {
     return GetEmptyStateValues();
   }
   size_t height = 0;
   size_t max_nodes = 1;
   while (count > max_nodes) {
     height++;
     max_nodes *= kMaxInputCount;
   }
 
   ValueArrayIterator it(values, count);
 
   Node* tree = BuildTree(&it, height);
 
   // If the 'tree' is a single node, equip it with a StateValues wrapper.
-  if (tree->opcode() != IrOpcode::kStateValues) {
+  if (tree->opcode() != IrOpcode::kStateValues &&
+      tree->opcode() != IrOpcode::kTypedStateValues) {
     tree = GetValuesNodeFromCache(&tree, 1);
   }
 
   return tree;
 }
 
 
 StateValuesAccess::iterator::iterator(Node* node) : current_depth_(0) {
   // A hacky way initialize - just set the index before the node we want
   // to process and then advance to it.
@@ skipping 38 matching lines @@
     int index = Top()->index;
 
     if (index >= node->InputCount()) {
       // Pop stack and move to the next sibling.
       Pop();
       if (done()) {
         // Stack is exhausted, we have reached the end.
         return;
       }
       Top()->index++;
-    } else if (node->InputAt(index)->opcode() == IrOpcode::kStateValues) {
+    } else if (node->InputAt(index)->opcode() == IrOpcode::kStateValues ||
+               node->InputAt(index)->opcode() == IrOpcode::kTypedStateValues) {
       // Nested state, we need to push to the stack.
       Push(node->InputAt(index));
     } else {
       // We are on a valid node, we can stop the iteration.
       return;
     }
   }
 }
 
 
 Node* StateValuesAccess::iterator::node() {
   return Top()->node->InputAt(Top()->index);
 }
 
 
+MachineType StateValuesAccess::iterator::type() {
+  Node* state = Top()->node;
+  if (state->opcode() == IrOpcode::kStateValues) {
+    return kMachAnyTagged;
+  } else {
+    DCHECK_EQ(IrOpcode::kTypedStateValues, state->opcode());
+    const ZoneVector<MachineType>* types =
+        OpParameter<const ZoneVector<MachineType>*>(state);
+    return (*types)[Top()->index];
+  }
+}
+
+
 bool StateValuesAccess::iterator::operator!=(iterator& other) {
   // We only allow comparison with end().
   CHECK(other.done());
   return !done();
 }
 
 
 StateValuesAccess::iterator& StateValuesAccess::iterator::operator++() {
   Advance();
   return *this;
 }
 
 
-Node* StateValuesAccess::iterator::operator*() { return node(); }
+StateValuesAccess::TypedNode StateValuesAccess::iterator::operator*() {
+  return TypedNode(node(), type());
+}
 
 
 size_t StateValuesAccess::size() {
   size_t count = 0;
   for (int i = 0; i < node_->InputCount(); i++) {
-    if (node_->InputAt(i)->opcode() == IrOpcode::kStateValues) {
+    if (node_->InputAt(i)->opcode() == IrOpcode::kStateValues ||
+        node_->InputAt(i)->opcode() == IrOpcode::kTypedStateValues) {
       count += StateValuesAccess(node_->InputAt(i)).size();
     } else {
       count++;
     }
   }
   return count;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8