[turbofan] Simplify NumberTo(U)Int32 handling in representation inference.

src/compiler/representation-change.h

 // 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.
 
 #ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_
 
 #include <sstream>
 
 #include "src/base/bits.h"
@@ skipping 193 matching lines @@
     } else if (output_type & kRepTagged) {
       op = simplified()->ChangeTaggedToFloat64();
     } else if (output_type & kRepFloat32) {
       op = machine()->ChangeFloat32ToFloat64();
     } else {
       return TypeError(node, output_type, kRepFloat64);
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
-  Node* MakeInt32Constant(double value) {
-    if (value < 0) {
-      DCHECK(IsInt32Double(value));
-      int32_t iv = static_cast<int32_t>(value);
-      return jsgraph()->Int32Constant(iv);
-    } else {
-      DCHECK(IsUint32Double(value));
-      int32_t iv = static_cast<int32_t>(static_cast<uint32_t>(value));
-      return jsgraph()->Int32Constant(iv);
-    }
+  Node* MakeTruncatedInt32Constant(double value) {
+    return jsgraph()->Int32Constant(DoubleToInt32(value));
   }
 
   Node* GetTruncatedWord32For(Node* node, MachineTypeUnion output_type) {
     // Eagerly fold truncations for constants.
     switch (node->opcode()) {
       case IrOpcode::kInt32Constant:
         return node;  // No change necessary.
       case IrOpcode::kFloat32Constant:
         return jsgraph()->Int32Constant(
             DoubleToInt32(OpParameter<float>(node)));
@@ skipping 19 matching lines @@
     }
     return jsgraph()->graph()->NewNode(op, node);
   }
 
   Node* GetWord32RepresentationFor(Node* node, MachineTypeUnion output_type) {
     // Eagerly fold representation changes for constants.
     switch (node->opcode()) {
       case IrOpcode::kInt32Constant:
         return node;  // No change necessary.
       case IrOpcode::kFloat32Constant:
-        return MakeInt32Constant(OpParameter<float>(node));
+        return MakeTruncatedInt32Constant(OpParameter<float>(node));
       case IrOpcode::kNumberConstant:
       case IrOpcode::kFloat64Constant:
-        return MakeInt32Constant(OpParameter<double>(node));
+        return MakeTruncatedInt32Constant(OpParameter<double>(node));
       default:
         break;
     }
     // Select the correct X -> Word32 operator.
     const Operator* op;
     Type* type = NodeProperties::GetType(node);
 
     if (output_type & kRepBit) {
       return node;  // Sloppy comparison -> word32
     } else if (output_type & kRepFloat64) {
@@ skipping 198 matching lines @@
   Factory* factory() const { return isolate()->factory(); }
   SimplifiedOperatorBuilder* simplified() { return jsgraph()->simplified(); }
   MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_