[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64.

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 1620 matching lines @@
 }
 
 void MacroAssembler::Trunc_ul_d(FPURegister fd, FPURegister fs,
                                 FPURegister scratch, Register result) {
   Trunc_ul_d(fs, t8, scratch, result);
   dmtc1(t8, fd);
 }
 
 
 void MacroAssembler::Trunc_ul_s(FPURegister fd, FPURegister fs,
-                                FPURegister scratch) {
-  Trunc_ul_s(fs, t8, scratch);
+                                FPURegister scratch, Register result) {
+  Trunc_ul_s(fs, t8, scratch, result);
   dmtc1(t8, fd);
 }
 
 
 void MacroAssembler::Trunc_w_d(FPURegister fd, FPURegister fs) {
   trunc_w_d(fd, fs);
 }
 
 
 void MacroAssembler::Round_w_d(FPURegister fd, FPURegister fs) {
@@ skipping 42 matching lines @@
 
   bind(&done);
 }
 
 
 void MacroAssembler::Trunc_ul_d(FPURegister fd, Register rs,
                                 FPURegister scratch, Register result) {
   DCHECK(!fd.is(scratch));
   DCHECK(!AreAliased(rs, result, at));
 
+  Label simple_convert, done, fail;
   if (result.is_valid()) {
     mov(result, zero_reg);
     Move(kDoubleRegZero, 0.0);
+    BranchF(&fail, &fail, lt, fd, kDoubleRegZero);
   }
 
   // Load 2^63 into scratch as its double representation.
   li(at, 0x43e0000000000000);
   dmtc1(at, scratch);
 
   // Test if scratch > fd.
   // If fd < 2^63 we can convert it normally.
   // If fd is unordered the conversion fails.
-  Label simple_convert, done, fail;
   BranchF(&simple_convert, &fail, lt, fd, scratch);
 
   // First we subtract 2^63 from fd, then trunc it to rs
   // and add 2^63 to rs.
   sub_d(scratch, fd, scratch);
   trunc_l_d(scratch, scratch);
   dmfc1(rs, scratch);
   Or(rs, rs, Operand(1UL << 63));
   Branch(&done);
 
   // Simple conversion.
   bind(&simple_convert);
   trunc_l_d(scratch, fd);
   dmfc1(rs, scratch);
 
   bind(&done);
   if (result.is_valid()) {
     // Conversion is failed if the result is negative or unordered.
     BranchF(&fail, &fail, lt, scratch, kDoubleRegZero);
     li(result, Operand(1));
   }
 
   bind(&fail);
 }
 
 
 void MacroAssembler::Trunc_ul_s(FPURegister fd, Register rs,
-                                FPURegister scratch) {
+                                FPURegister scratch, Register result) {
   DCHECK(!fd.is(scratch));
-  DCHECK(!rs.is(at));
+  DCHECK(!AreAliased(rs, result, at));
+
+  Label simple_convert, done, fail;
+  if (result.is_valid()) {
+    mov(result, zero_reg);
+    Move(kDoubleRegZero, 0.0);
+    // If fd < 0 or unordered, then the conversion fails.
+    BranchF32(&fail, &fail, lt, fd, kDoubleRegZero);
+  }
 
   // Load 2^63 into scratch as its float representation.
   li(at, 0x5f000000);
-  dmtc1(at, scratch);
+  mtc1(at, scratch);
 
   // Test if scratch > fd.
   // If fd < 2^63 we can convert it normally.
-  Label simple_convert, done;
-  BranchF32(&simple_convert, NULL, lt, fd, scratch);
+  // // If fd is unordered the conversion fails.
+  BranchF32(&simple_convert, nullptr, lt, fd, scratch);
 
   // First we subtract 2^63 from fd, then trunc it to rs
   // and add 2^63 to rs.
   sub_s(scratch, fd, scratch);
   trunc_l_s(scratch, scratch);
   dmfc1(rs, scratch);
   Or(rs, rs, Operand(1UL << 63));
   Branch(&done);
 
   // Simple conversion.
   bind(&simple_convert);
   trunc_l_s(scratch, fd);
   dmfc1(rs, scratch);
 
   bind(&done);
+  if (result.is_valid()) {
+    // Conversion is failed if the result is negative or unordered.
+    BranchF(&fail, &fail, lt, scratch, kDoubleRegZero);

[ahaas, 2015/12/09 17:10:01]

@v8-mips-ports: originally I wanted to use BranchF32 here, but then some tests
fail. What's the reason why BranchF has to be used here?

[paul.l..., 2015/12/10 06:51:57]

This is clearly broken, but I could not spot the bug tonight. I've created an
internal issue for it. Why don't you land this with the BranchF() when you are
ready, and we'll fix it in followup CL.

+    li(result, Operand(1));
+  }
+
+  bind(&fail);
 }
 
 
 void MacroAssembler::Madd_d(FPURegister fd, FPURegister fr, FPURegister fs,
     FPURegister ft, FPURegister scratch) {
   if (0) {  // TODO(plind): find reasonable arch-variant symbol names.
     madd_d(fd, fr, fs, ft);
   } else {
     // Can not change source regs's value.
     DCHECK(!fr.is(scratch) && !fs.is(scratch) && !ft.is(scratch));
@@ skipping 4517 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