MIPS: Fix '[turbofan] Introduce new operators Float32SubPreserveNan and Float64SubPreserveNan'.

src/mips64/macro-assembler-mips64.cc

 // Copyright 2012 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.h>  // For LONG_MIN, LONG_MAX.
 
 #if V8_TARGET_ARCH_MIPS64
 
 #include "src/base/division-by-constant.h"
 #include "src/bootstrapper.h"
@@ skipping 4836 matching lines @@
   bind(&done);
   Daddu(scratch1, elements_reg,
       Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag -
               elements_offset));
   dsra(scratch2, key_reg, 32 - kDoubleSizeLog2);
   Daddu(scratch1, scratch1, scratch2);
   // scratch1 is now effective address of the double element.
   sdc1(double_result, MemOperand(scratch1, 0));
 }
 
+void MacroAssembler::SubNanPreservePayloadAndSign_s(FPURegister fd,
+                                                    FPURegister fs,
+                                                    FPURegister ft) {
+  Label maybe_nan, nan2008, not_nan2008, done;
+  Register scratch1 = t8;
+  Register scratch2 = t9;
+  DoubleRegister double_scratch = f8;
+
+  sub_s(fd, fs, ft);
+  // Check if the result of subtraction is NaN or infinity.
+  sub_s(double_scratch, fd, fd);
+  BranchF32(&done, nullptr, eq, double_scratch, kDoubleRegZero);
+
+  // Check if first operand is a possible NaN.
+  dmfc1(scratch1, fs);
+  And(scratch2, scratch1, Operand(FloatConstants::kExponentMask));
+  Branch(&maybe_nan, eq, scratch2, Operand(FloatConstants::kExponentMask));
+  // Check if second operand is a possible NaN.
+  dmfc1(scratch1, ft);
+  And(scratch2, scratch1, Operand(FloatConstants::kExponentMask));
+  Branch(&done, ne, scratch2, Operand(FloatConstants::kExponentMask));
+
+  // Check if possible NaN is actually NaN.
+  bind(&maybe_nan);
+  And(scratch2, scratch1, Operand(FloatConstants::kMantissaMask));
+  Branch(&done, eq, scratch2, Operand(zero_reg));
+  // If NaN is found, return it as qNaN with same payload.
+  // Determine the qNaN encoding for the current architecture.
+  LoadRoot(scratch2, Heap::kNanValueRootIndex);
+  ldc1(double_scratch, FieldMemOperand(scratch2, HeapNumber::kValueOffset));
+  dmfc1(scratch2, double_scratch);
+  And(scratch2, scratch2, Operand(DoubleConstants::kNanTypeMask));
+  // Make NaN quiet.
+  Branch(&nan2008, gt, scratch2, Operand(zero_reg));
+  And(scratch1, scratch1, Operand(~FloatConstants::kNanTypeMask));
+  Branch(&not_nan2008);
+  bind(&nan2008);
+  Or(scratch1, scratch1, Operand(FloatConstants::kNanTypeMask));
+  bind(&not_nan2008);
+  dmtc1(scratch1, fd);
+  bind(&done);
+}
+
+void MacroAssembler::SubNanPreservePayloadAndSign_d(FPURegister fd,
+                                                    FPURegister fs,
+                                                    FPURegister ft) {
+  Label maybe_nan, nan2008, not_nan2008, done;
+  Register scratch1 = t8;
+  Register scratch2 = t9;
+  DoubleRegister double_scratch = f8;
+
+  sub_d(fd, fs, ft);
+  // Check if the result of subtraction is NaN or infinity.
+  sub_d(double_scratch, fd, fd);
+  BranchF64(&done, nullptr, eq, double_scratch, kDoubleRegZero);
+
+  // Check if first operand is a possible NaN.
+  dmfc1(scratch1, fs);
+  And(scratch2, scratch1, Operand(DoubleConstants::kExponentMask));
+  Branch(&maybe_nan, eq, scratch2, Operand(DoubleConstants::kExponentMask));
+  // Check if second operand is a possible NaN.
+  dmfc1(scratch1, ft);
+  And(scratch2, scratch1, Operand(DoubleConstants::kExponentMask));
+  Branch(&done, ne, scratch2, Operand(DoubleConstants::kExponentMask));
+
+  // Check if possible NaN is actually NaN.
+  bind(&maybe_nan);
+  And(scratch2, scratch1, Operand(DoubleConstants::kMantissaMask));
+  Branch(&done, eq, scratch2, Operand(zero_reg));
+  // If NaN is found, return it as qNaN with same payload.
+  // Determine the qNaN encoding for the current architecture.
+  LoadRoot(scratch2, Heap::kNanValueRootIndex);
+  ldc1(double_scratch, FieldMemOperand(scratch2, HeapNumber::kValueOffset));
+  dmfc1(scratch2, double_scratch);
+  And(scratch2, scratch2, Operand(DoubleConstants::kNanTypeMask));
+  // Make NaN quiet.
+  Branch(&nan2008, gt, scratch2, Operand(zero_reg));
+  And(scratch1, scratch1, Operand(~DoubleConstants::kNanTypeMask));
+  Branch(&not_nan2008);
+  bind(&nan2008);
+  Or(scratch1, scratch1, Operand(DoubleConstants::kNanTypeMask));
+  bind(&not_nan2008);
+  dmtc1(scratch1, fd);
+  bind(&done);
+}
 
 void MacroAssembler::CompareMapAndBranch(Register obj,
                                          Register scratch,
                                          Handle<Map> map,
                                          Label* early_success,
                                          Condition cond,
                                          Label* branch_to) {
   ld(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
   CompareMapAndBranch(scratch, map, early_success, cond, branch_to);
 }
@@ skipping 2273 matching lines @@
   if (mag.shift > 0) sra(result, result, mag.shift);
   srl(at, dividend, 31);
   Addu(result, result, Operand(at));
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64