Relax representation requirement in FrameStates.

src/compiler/simplified-lowering.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/simplified-lowering.h"
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
@@ skipping 266 matching lines @@
       Node::Inputs inputs = node->inputs();
       for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
            ++iter, --values) {
         // TODO(titzer): it'd be nice to have distinguished edge kinds here.
         ProcessInput(node, iter.index(), values > 0 ? use : 0);
       }
     }
     // Phis adapt to whatever output representation their uses demand,
     // pushing representation changes to their inputs.
     MachineTypeUnion use_rep = GetUseInfo(node) & kRepMask;
-    MachineTypeUnion use_type = GetUseInfo(node) & kTypeMask;
+    Type* upper = NodeProperties::GetBounds(node).upper;
+    MachineTypeUnion phi_type = changer_->TypeFromUpperBound(upper);
     MachineTypeUnion rep = 0;
     if (use_rep & kRepTagged) {
       rep = kRepTagged;  // Tagged overrides everything.
     } else if (use_rep & kRepFloat32) {
       rep = kRepFloat32;
     } else if (use_rep & kRepFloat64) {
       rep = kRepFloat64;
     } else if (use_rep & kRepWord64) {
       rep = kRepWord64;
     } else if (use_rep & kRepWord32) {
-      rep = kRepWord32;
+      if (phi_type & kTypeNumber) {
+        rep = kRepFloat64;
+      } else {
+        rep = kRepWord32;
+      }
     } else if (use_rep & kRepBit) {
       rep = kRepBit;
     } else {
       // There was no representation associated with any of the uses.
-      // TODO(titzer): Select the best rep using phi's type, not the usage type?
-      if (use_type & kTypeAny) {
+      if (phi_type & kTypeAny) {
         rep = kRepTagged;
-      } else if (use_type & kTypeNumber) {
+      } else if (phi_type & kTypeNumber) {
         rep = kRepFloat64;
-      } else if (use_type & kTypeInt64 || use_type & kTypeUint64) {
+      } else if (phi_type & kTypeInt64 || phi_type & kTypeUint64) {
         rep = kRepWord64;
-      } else if (use_type & kTypeInt32 || use_type & kTypeUint32) {
+      } else if (phi_type & kTypeInt32 || phi_type & kTypeUint32) {
         rep = kRepWord32;
-      } else if (use_type & kTypeBool) {
+      } else if (phi_type & kTypeBool) {
         rep = kRepBit;
       } else {
         UNREACHABLE();  // should have at least a usage type!
       }
     }
     // Preserve the usage type, but set the representation.
-    Type* upper = NodeProperties::GetBounds(node).upper;
-    MachineTypeUnion output_type = rep | changer_->TypeFromUpperBound(upper);
+    MachineTypeUnion output_type = rep | phi_type;
     SetOutput(node, output_type);
 
     if (lower()) {
       int values = OperatorProperties::GetValueInputCount(node->op());
 
       // Update the phi operator.
       MachineType type = static_cast<MachineType>(output_type);
       if (type != OpParameter<MachineType>(node)) {
         node->set_op(lowering->common()->Phi(type, values));
       }
@@ skipping 390 matching lines @@
       case IrOpcode::kFloat64Mod:
         return VisitFloat64Binop(node);
       case IrOpcode::kFloat64Sqrt:
         return VisitUnop(node, kMachFloat64, kMachFloat64);
       case IrOpcode::kFloat64Equal:
       case IrOpcode::kFloat64LessThan:
       case IrOpcode::kFloat64LessThanOrEqual:
         return VisitFloat64Cmp(node);
       case IrOpcode::kLoadStackPointer:
         return VisitLeaf(node, kMachPtr);
+      case IrOpcode::kStateValues:
+        for (int i = 0; i < node->InputCount(); i++) {
+          ProcessInput(node, i, kTypeAny);
+        }
+        SetOutput(node, kMachAnyTagged);
+        break;
       default:
         VisitInputs(node);
         break;
     }
   }
 
   void DeferReplacement(Node* node, Node* replacement) {
     if (replacement->id() < count_) {
       // Replace with a previously existing node eagerly.
       node->ReplaceUses(replacement);
@@ skipping 223 matching lines @@
 void SimplifiedLowering::DoStringLessThanOrEqual(Node* node) {
   node->set_op(machine()->IntLessThanOrEqual());
   node->ReplaceInput(0, StringComparison(node, true));
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8