[builtins] Don't canonicalize results of Math double operations.

src/builtins/builtins-number.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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 917 matching lines @@
     var_result.Bind(assembler->CallStub(callable, context, var_lhs.value(),
                                         var_rhs.value()));
     assembler->Goto(&end);
   }
 
   assembler->Bind(&do_fadd);
   {
     Node* lhs_value = var_fadd_lhs.value();
     Node* rhs_value = var_fadd_rhs.value();
     Node* value = assembler->Float64Add(lhs_value, rhs_value);
-    Node* result = assembler->ChangeFloat64ToTagged(value);
+    Node* result = assembler->AllocateHeapNumberWithValue(value);
     var_result.Bind(result);
     assembler->Goto(&end);
   }
   assembler->Bind(&end);
   assembler->Return(var_result.value());
 }
 
 void Builtins::Generate_Subtract(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
@@ skipping 158 matching lines @@
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fsub);
   {
     Node* lhs_value = var_fsub_lhs.value();
     Node* rhs_value = var_fsub_rhs.value();
     Node* value = assembler->Float64Sub(lhs_value, rhs_value);
-    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    var_result.Bind(assembler->AllocateHeapNumberWithValue(value));
     assembler->Goto(&end);
   }
   assembler->Bind(&end);
   assembler->Return(var_result.value());
 }
 
 void Builtins::Generate_Multiply(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
@@ skipping 131 matching lines @@
         var_lhs.Bind(assembler->CallStub(callable, context, lhs));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fmul);
   {
     Node* value =
         assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
-    Node* result = assembler->ChangeFloat64ToTagged(value);
+    Node* result = assembler->AllocateHeapNumberWithValue(value);
     var_result.Bind(result);
     assembler->Goto(&return_result);
   }
 
   assembler->Bind(&return_result);
   assembler->Return(var_result.value());
 }
 
 void Builtins::Generate_Divide(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
@@ skipping 199 matching lines @@
         var_dividend.Bind(assembler->CallStub(callable, context, dividend));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fdiv);
   {
     Node* value = assembler->Float64Div(var_dividend_float64.value(),
                                         var_divisor_float64.value());
-    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    var_result.Bind(assembler->AllocateHeapNumberWithValue(value));
     assembler->Goto(&end);
   }
   assembler->Bind(&end);
   assembler->Return(var_result.value());
 }
 
 void Builtins::Generate_Modulus(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
@@ skipping 137 matching lines @@
         var_dividend.Bind(assembler->CallStub(callable, context, dividend));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fmod);
   {
     Node* value = assembler->Float64Mod(var_dividend_float64.value(),
                                         var_divisor_float64.value());
-    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    var_result.Bind(assembler->AllocateHeapNumberWithValue(value));
     assembler->Goto(&return_result);
   }
 
   assembler->Bind(&return_result);
   assembler->Return(var_result.value());
 }
 
 void Builtins::Generate_ShiftLeft(CodeStubAssembler* assembler) {
   compiler::Node* left = assembler->Parameter(0);
   compiler::Node* right = assembler->Parameter(1);
@@ skipping 151 matching lines @@
   compiler::Node* lhs = assembler->Parameter(0);
   compiler::Node* rhs = assembler->Parameter(1);
   compiler::Node* context = assembler->Parameter(2);
 
   assembler->Return(assembler->StrictEqual(CodeStubAssembler::kNegateResult,
                                            lhs, rhs, context));
 }
 
 }  // namespace internal
 }  // namespace v8