[turbofan] Correctify representation changes to bit.

test/cctest/compiler/test-representation-change.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 <limits>
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
@@ skipping 61 matching lines @@
     CHECK_EQ(expected, *m.Value().handle());
   }
 
   void CheckNumberConstant(Node* n, double expected) {
     NumberMatcher m(n);
     CHECK_EQ(IrOpcode::kNumberConstant, n->opcode());
     CHECK(m.HasValue());
     CHECK_EQ(expected, m.Value());
   }
 
-  Node* Parameter(int index = 0) {
-    return graph()->NewNode(common()->Parameter(index), graph()->start());
+  Node* Parameter(Type* type, int index = 0) {
+    Node* node = graph()->NewNode(common()->Parameter(index), graph()->start());
+    NodeProperties::SetBounds(node, Bounds(type));
+    return node;
   }
 
+  Node* Parameter(int index = 0) { return Parameter(Type::Any(), index); }
+
   void CheckTypeError(MachineTypeUnion from, MachineTypeUnion to) {
     changer()->testing_type_errors_ = true;
     changer()->type_error_ = false;
     Node* n = Parameter(0);
     Node* c = changer()->GetRepresentationFor(n, from, to);
     CHECK(changer()->type_error_);
     CHECK_EQ(n, c);
   }
 
   void CheckNop(MachineTypeUnion from, MachineTypeUnion to) {
     Node* n = Parameter(0);
     Node* c = changer()->GetRepresentationFor(n, from, to);
     CHECK_EQ(n, c);
   }
 };
-}
-}
-}  // namespace v8::internal::compiler
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8
 
 
 static const MachineType all_reps[] = {kRepBit,     kRepWord32,  kRepWord64,
                                        kRepFloat32, kRepFloat64, kRepTagged};
 
 
-TEST(BoolToBit_constant) {
+TEST(ToBit_constant) {
   RepresentationChangerTester r;
 
   Node* true_node = r.jsgraph()->TrueConstant();
   Node* true_bit =
       r.changer()->GetRepresentationFor(true_node, kRepTagged, kRepBit);
   r.CheckInt32Constant(true_bit, 1);
 
   Node* false_node = r.jsgraph()->FalseConstant();
   Node* false_bit =
       r.changer()->GetRepresentationFor(false_node, kRepTagged, kRepBit);
   r.CheckInt32Constant(false_bit, 0);
+
+  {
+    FOR_FLOAT64_INPUTS(i) {
+      Node* node = r.jsgraph()->Constant(*i);
+      Node* bit = r.changer()->GetRepresentationFor(node, kRepTagged, kRepBit);
+      r.CheckInt32Constant(bit, DoubleToBoolean(*i) ? 1 : 0);
+    }
+  }
+
+  {
+    FOR_INT32_INPUTS(i) {
+      Node* node = r.jsgraph()->Int32Constant(*i);
+      Node* bit = r.changer()->GetRepresentationFor(node, kRepWord32, kRepBit);
+      r.CheckInt32Constant(bit, *i == 0 ? 0 : 1);
+    }
+  }
 }
 
 
 TEST(BitToBool_constant) {
   RepresentationChangerTester r;
 
   for (int i = -5; i < 5; i++) {
     Node* node = r.jsgraph()->Int32Constant(i);
     Node* val = r.changer()->GetRepresentationFor(node, kRepBit, kRepTagged);
     r.CheckHeapConstant(val, i == 0 ? r.isolate()->heap()->false_value()
@@ skipping 231 matching lines @@
       Node* n = r.jsgraph()->Constant(static_cast<double>(*i));
       Node* c = r.changer()->GetRepresentationFor(n, kRepTagged | kTypeUint32,
                                                   kRepWord32);
       r.CheckUint32Constant(c, *i);
     }
   }
 }
 
 
 static void CheckChange(IrOpcode::Value expected, MachineTypeUnion from,
-                        MachineTypeUnion to) {
+                        MachineTypeUnion to, Type* from_type = Type::Any()) {
   RepresentationChangerTester r;
 
-  Node* n = r.Parameter();
+  Node* n = r.Parameter(from_type);
   Node* c = r.changer()->GetRepresentationFor(n, from, to);
 
   CHECK_NE(c, n);
   CHECK_EQ(expected, c->opcode());
   CHECK_EQ(n, c->InputAt(0));
 }
 
 
 static void CheckTwoChanges(IrOpcode::Value expected2,
                             IrOpcode::Value expected1, MachineTypeUnion from,
-                            MachineTypeUnion to) {
+                            MachineTypeUnion to,
+                            Type* from_type = Type::Any()) {
   RepresentationChangerTester r;
 
-  Node* n = r.Parameter();
+  Node* n = r.Parameter(from_type);
   Node* c1 = r.changer()->GetRepresentationFor(n, from, to);
 
   CHECK_NE(c1, n);
   CHECK_EQ(expected1, c1->opcode());
   Node* c2 = c1->InputAt(0);
   CHECK_NE(c2, n);
   CHECK_EQ(expected2, c2->opcode());
   CHECK_EQ(n, c2->InputAt(0));
 }
 
 
 TEST(SingleChanges) {
-  CheckChange(IrOpcode::kChangeBoolToBit, kRepTagged, kRepBit);
+  CheckChange(IrOpcode::kChangeBoolToBit, kRepTagged, kRepBit, Type::Boolean());
+  CheckTwoChanges(IrOpcode::kChangeTaggedToInt32, IrOpcode::kChangeWord32ToBit,
+                  kRepTagged, kRepBit, Type::Signed32());
+  CheckTwoChanges(IrOpcode::kChangeTaggedToUint32, IrOpcode::kChangeWord32ToBit,
+                  kRepTagged, kRepBit, Type::Unsigned32());
+  CheckChange(IrOpcode::kChangeWord32ToBit, kRepWord8, kRepBit);
+  CheckChange(IrOpcode::kChangeWord32ToBit, kRepWord16, kRepBit);
+  CheckChange(IrOpcode::kChangeWord32ToBit, kRepWord32, kRepBit);
+  CheckChange(IrOpcode::kChangeWord64ToBit, kRepWord64, kRepBit);
   CheckChange(IrOpcode::kChangeBitToBool, kRepBit, kRepTagged);
 
   CheckChange(IrOpcode::kChangeInt32ToTagged, kRepWord32 | kTypeInt32,
               kRepTagged);
   CheckChange(IrOpcode::kChangeUint32ToTagged, kRepWord32 | kTypeUint32,
               kRepTagged);
   CheckChange(IrOpcode::kChangeFloat64ToTagged, kRepFloat64, kRepTagged);
 
   CheckChange(IrOpcode::kChangeTaggedToInt32, kRepTagged | kTypeInt32,
               kRepWord32);
@@ skipping 59 matching lines @@
   // X -> X is always a nop for any single representation X.
   for (size_t i = 0; i < arraysize(all_reps); i++) {
     r.CheckNop(all_reps[i], all_reps[i]);
   }
 
   // 32-bit floats.
   r.CheckNop(kRepFloat32, kRepFloat32);
   r.CheckNop(kRepFloat32 | kTypeNumber, kRepFloat32);
   r.CheckNop(kRepFloat32, kRepFloat32 | kTypeNumber);
 
-  // 32-bit or 64-bit words can be used as branch conditions (kRepBit).
-  r.CheckNop(kRepWord32, kRepBit);
-  r.CheckNop(kRepWord32, kRepBit | kTypeBool);
-  r.CheckNop(kRepWord64, kRepBit);
-  r.CheckNop(kRepWord64, kRepBit | kTypeBool);
-
   // 32-bit words can be used as smaller word sizes and vice versa, because
   // loads from memory implicitly sign or zero extend the value to the
   // full machine word size, and stores implicitly truncate.
   r.CheckNop(kRepWord32, kRepWord8);
   r.CheckNop(kRepWord32, kRepWord16);
   r.CheckNop(kRepWord32, kRepWord32);
   r.CheckNop(kRepWord8, kRepWord32);
   r.CheckNop(kRepWord16, kRepWord32);
 
   // kRepBit (result of comparison) is implicitly a wordish thing.
@@ skipping 39 matching lines @@
   r.CheckTypeError(kRepWord32 | kTypeUint32, kRepWord64);
 
   for (size_t i = 0; i < arraysize(all_reps); i++) {
     for (size_t j = 0; j < arraysize(all_reps); j++) {
       if (i == j) continue;
       // Only a single from representation is allowed.
       r.CheckTypeError(all_reps[i] | all_reps[j], kRepTagged);
     }
   }
 }