[stubs] Don't unconditionally canonicalize in ChangeFloat64ToTagged.

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 1852 matching lines @@
   }
   Bind(&done_loop);
   return var_result.value();
 }
 
 Node* CodeStubAssembler::TruncateHeapNumberValueToWord32(Node* object) {
   Node* value = LoadHeapNumberValue(object);
   return TruncateFloat64ToWord32(value);
 }
 
-Node* CodeStubAssembler::ChangeFloat64ToTagged(Node* value) {
-  Node* value32 = RoundFloat64ToInt32(value);
-  Node* value64 = ChangeInt32ToFloat64(value32);
+Node* CodeStubAssembler::ChangeFloat64ToTagged(Node* value,
+                                               CanonicalizationMode mode) {
+  switch (mode) {
+    case CanonicalizationMode::kDontCanonicalize: {
+      return AllocateHeapNumberWithValue(value);
+    }
+    case CanonicalizationMode::kCanonicalize: {
+      Node* value32 = RoundFloat64ToInt32(value);
+      Node* value64 = ChangeInt32ToFloat64(value32);
 
-  Label if_valueisint32(this), if_valueisheapnumber(this), if_join(this);
+      Label if_valueisint32(this), if_valueisheapnumber(this), if_join(this);
 
-  Label if_valueisequal(this), if_valueisnotequal(this);
-  Branch(Float64Equal(value, value64), &if_valueisequal, &if_valueisnotequal);
-  Bind(&if_valueisequal);
-  {
-    GotoUnless(Word32Equal(value32, Int32Constant(0)), &if_valueisint32);
-    BranchIfInt32LessThan(Float64ExtractHighWord32(value), Int32Constant(0),
-                          &if_valueisheapnumber, &if_valueisint32);
-  }
-  Bind(&if_valueisnotequal);
-  Goto(&if_valueisheapnumber);
+      Label if_valueisequal(this), if_valueisnotequal(this);
+      Branch(Float64Equal(value, value64), &if_valueisequal,
+             &if_valueisnotequal);
+      Bind(&if_valueisequal);
+      {
+        GotoUnless(Word32Equal(value32, Int32Constant(0)), &if_valueisint32);
+        BranchIfInt32LessThan(Float64ExtractHighWord32(value), Int32Constant(0),
+                              &if_valueisheapnumber, &if_valueisint32);
+      }
+      Bind(&if_valueisnotequal);
+      Goto(&if_valueisheapnumber);
 
-  Variable var_result(this, MachineRepresentation::kTagged);
-  Bind(&if_valueisint32);
-  {
-    if (Is64()) {
-      Node* result = SmiTag(ChangeInt32ToInt64(value32));
-      var_result.Bind(result);
-      Goto(&if_join);
-    } else {
-      Node* pair = Int32AddWithOverflow(value32, value32);
-      Node* overflow = Projection(1, pair);
-      Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
-      Branch(overflow, &if_overflow, &if_notoverflow);
-      Bind(&if_overflow);
-      Goto(&if_valueisheapnumber);
-      Bind(&if_notoverflow);
+      Variable var_result(this, MachineRepresentation::kTagged);
+      Bind(&if_valueisint32);
       {
-        Node* result = Projection(0, pair);
+        if (Is64()) {
+          Node* result = SmiTag(ChangeInt32ToInt64(value32));
+          var_result.Bind(result);
+          Goto(&if_join);
+        } else {
+          Node* pair = Int32AddWithOverflow(value32, value32);
+          Node* overflow = Projection(1, pair);
+          Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
+          Branch(overflow, &if_overflow, &if_notoverflow);
+          Bind(&if_overflow);
+          Goto(&if_valueisheapnumber);
+          Bind(&if_notoverflow);
+          {
+            Node* result = Projection(0, pair);
+            var_result.Bind(result);
+            Goto(&if_join);
+          }
+        }
+      }
+      Bind(&if_valueisheapnumber);
+      {
+        Node* result = AllocateHeapNumberWithValue(value);
         var_result.Bind(result);
         Goto(&if_join);
       }
+      Bind(&if_join);
+      return var_result.value();
     }
   }
-  Bind(&if_valueisheapnumber);
-  {
-    Node* result = AllocateHeapNumberWithValue(value);
-    var_result.Bind(result);
-    Goto(&if_join);
-  }
-  Bind(&if_join);
-  return var_result.value();
+  UNREACHABLE();
+  return nullptr;
 }
 
 Node* CodeStubAssembler::ChangeInt32ToTagged(Node* value) {
   if (Is64()) {
     return SmiTag(ChangeInt32ToInt64(value));
   }
   Variable var_result(this, MachineRepresentation::kTagged);
   Node* pair = Int32AddWithOverflow(value, value);
   Node* overflow = Projection(1, pair);
   Label if_overflow(this, Label::kDeferred), if_notoverflow(this),
@@ skipping 695 matching lines @@
     {
       // Load the floating-point value of {arg}.
       Node* arg_value = LoadHeapNumberValue(arg);
 
       // Check if {arg} is NaN.
       GotoUnless(Float64Equal(arg_value, arg_value), &return_zero);
 
       // Truncate {arg} towards zero.
       Node* value = Float64Trunc(arg_value);
 
-      if (mode == kTruncateMinusZero) {
-        // Truncate -0.0 to 0.
-        GotoIf(Float64Equal(value, Float64Constant(0.0)), &return_zero);
+      // Perform optional minus zero truncation.
+      switch (mode) {
+        case kNoTruncation:
+          break;
+        case kTruncateMinusZero: {
+          // Truncate -0.0 to 0.
+          GotoIf(Float64Equal(value, Float64Constant(0.0)), &return_zero);
+          break;
+        }
       }
 
-      var_arg.Bind(ChangeFloat64ToTagged(value));
+      // Tag the {value} using Smi canonicalization, i.e. if {value} can be
+      // represented as a Smi, then this will produce a Smi.
+      var_arg.Bind(
+          ChangeFloat64ToTagged(value, CanonicalizationMode::kCanonicalize));
       Goto(&out);
     }
 
     Bind(&if_argisnotheapnumber);
     {
       // Need to convert {arg} to a Number first.
       Callable callable = CodeFactory::NonNumberToNumber(isolate());
       var_arg.Bind(CallStub(callable, context, arg));
       Goto(&loop);
     }
@@ skipping 2657 matching lines @@
                        Heap::kTheHoleValueRootIndex);
 
   // Store the WeakCell in the feedback vector.
   StoreFixedArrayElement(feedback_vector, slot, cell, UPDATE_WRITE_BARRIER,
                          CodeStubAssembler::SMI_PARAMETERS);
   return cell;
 }
 
 }  // namespace internal
 }  // namespace v8