Use TruncateFloat64ToInt32 instead of ChangeFloat64ToInt32 in lowering of simplified operators Numb…

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/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/representation-change.h"
@@ skipping 435 matching lines @@
         MachineTypeUnion use_rep = use & kRepMask;
         if (lower()) {
           MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
           if ((in & kTypeMask) == kTypeInt32 || (in & kRepMask) == kRepWord32) {
             // If the input has type int32, or is already a word32, just change
             // representation if necessary.
             VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | use_rep);
             DeferReplacement(node, node->InputAt(0));
           } else {
             // Require the input in float64 format and perform truncation.
-            // TODO(turbofan): could also avoid the truncation with a tag check.
+            // TODO(turbofan): avoid a truncation with a smi check.
             VisitUnop(node, kTypeInt32 | kRepFloat64, kTypeInt32 | kRepWord32);
-            // TODO(titzer): should be a truncation.
-            node->set_op(lowering->machine()->ChangeFloat64ToInt32());
+            node->set_op(lowering->machine()->TruncateFloat64ToInt32());
           }
         } else {
           // Propagate a type to the input, but pass through representation.
           VisitUnop(node, kTypeInt32, kTypeInt32 | use_rep);
         }
         break;
       }
       case IrOpcode::kNumberToUint32: {
         MachineTypeUnion use_rep = use & kRepMask;
         if (lower()) {
           MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
           if ((in & kTypeMask) == kTypeUint32 ||
               (in & kRepMask) == kRepWord32) {
             // The input has type int32, just change representation.
             VisitUnop(node, kTypeUint32 | use_rep, kTypeUint32 | use_rep);
             DeferReplacement(node, node->InputAt(0));
           } else {
             // Require the input in float64 format to perform truncation.
-            // TODO(turbofan): could also avoid the truncation with a tag check.
+            // TODO(turbofan): avoid the truncation with a smi check.
             VisitUnop(node, kTypeUint32 | kRepFloat64,
                       kTypeUint32 | kRepWord32);
-            // TODO(titzer): should be a truncation.
-            node->set_op(lowering->machine()->ChangeFloat64ToUint32());
+            node->set_op(lowering->machine()->TruncateFloat64ToInt32());
           }
         } else {
           // Propagate a type to the input, but pass through representation.
           VisitUnop(node, kTypeUint32, kTypeUint32 | use_rep);
         }
         break;
       }
       case IrOpcode::kReferenceEqual: {
         VisitBinop(node, kMachAnyTagged, kRepBit);
         if (lower()) node->set_op(lowering->machine()->WordEqual());
@@ skipping 312 matching lines @@
   WriteBarrierKind kind = ComputeWriteBarrierKind(
       access.base_is_tagged, access.machine_type, access.type);
   node->set_op(machine_.Store(access.machine_type, kind));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8