s390: improve floating point and integer convertion

src/s390/macro-assembler-s390.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 <assert.h>  // For assert
 #include <limits.h>  // For LONG_MIN, LONG_MAX.
 
 #if V8_TARGET_ARCH_S390
 
 #include "src/base/bits.h"
@@ skipping 619 matching lines @@
 }
 
 void MacroAssembler::CanonicalizeNaN(const DoubleRegister dst,
                                      const DoubleRegister src) {
   // Turn potential sNaN into qNaN
   if (!dst.is(src)) ldr(dst, src);
   lzdr(kDoubleRegZero);
   sdbr(dst, kDoubleRegZero);
 }
 
-void MacroAssembler::ConvertIntToDouble(Register src, DoubleRegister dst) {
+void MacroAssembler::ConvertIntToDouble(DoubleRegister dst, Register src) {
   cdfbr(dst, src);
 }
 
-void MacroAssembler::ConvertUnsignedIntToDouble(Register src,
-                                                DoubleRegister dst) {
+void MacroAssembler::ConvertUnsignedIntToDouble(DoubleRegister dst,
+                                                Register src) {
   if (CpuFeatures::IsSupported(FLOATING_POINT_EXT)) {
     cdlfbr(Condition(5), Condition(0), dst, src);
   } else {
     // zero-extend src
     llgfr(src, src);
     // convert to double
     cdgbr(dst, src);
   }
 }
 
-void MacroAssembler::ConvertIntToFloat(Register src, DoubleRegister dst) {
+void MacroAssembler::ConvertIntToFloat(DoubleRegister dst, Register src) {
   cefbr(Condition(4), dst, src);
 }
 
-void MacroAssembler::ConvertUnsignedIntToFloat(Register src,
-                                               DoubleRegister dst) {
+void MacroAssembler::ConvertUnsignedIntToFloat(DoubleRegister dst,
+                                               Register src) {
   celfbr(Condition(4), Condition(0), dst, src);
 }
 
-#if V8_TARGET_ARCH_S390X
-void MacroAssembler::ConvertInt64ToDouble(Register src,
-                                          DoubleRegister double_dst) {
+void MacroAssembler::ConvertInt64ToFloat(DoubleRegister double_dst,
+                                         Register src) {
+  cegbr(double_dst, src);
+}
+
+void MacroAssembler::ConvertInt64ToDouble(DoubleRegister double_dst,
+                                          Register src) {
   cdgbr(double_dst, src);
 }
 
-void MacroAssembler::ConvertUnsignedInt64ToFloat(Register src,
-                                                 DoubleRegister double_dst) {
+void MacroAssembler::ConvertUnsignedInt64ToFloat(DoubleRegister double_dst,
+                                                 Register src) {
   celgbr(Condition(0), Condition(0), double_dst, src);
 }
 
-void MacroAssembler::ConvertUnsignedInt64ToDouble(Register src,
-                                                  DoubleRegister double_dst) {
+void MacroAssembler::ConvertUnsignedInt64ToDouble(DoubleRegister double_dst,
+                                                  Register src) {
   cdlgbr(Condition(0), Condition(0), double_dst, src);
 }
 
-void MacroAssembler::ConvertInt64ToFloat(Register src,
-                                         DoubleRegister double_dst) {
-  cegbr(double_dst, src);
-}
-#endif
-
-void MacroAssembler::ConvertFloat32ToInt64(const DoubleRegister double_input,
-#if !V8_TARGET_ARCH_S390X
-                                           const Register dst_hi,
-#endif
-                                           const Register dst,
-                                           const DoubleRegister double_dst,
+void MacroAssembler::ConvertFloat32ToInt64(const Register dst,
+                                           const DoubleRegister double_input,
                                            FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       UNIMPLEMENTED();
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
   cgebr(m, dst, double_input);
-  ldgr(double_dst, dst);
-#if !V8_TARGET_ARCH_S390X
-  srlg(dst_hi, dst, Operand(32));
-#endif
 }
 
-void MacroAssembler::ConvertDoubleToInt64(const DoubleRegister double_input,
-#if !V8_TARGET_ARCH_S390X
-                                          const Register dst_hi,
-#endif
-                                          const Register dst,
-                                          const DoubleRegister double_dst,
+void MacroAssembler::ConvertDoubleToInt64(const Register dst,
+                                          const DoubleRegister double_input,
                                           FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       UNIMPLEMENTED();
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
   cgdbr(m, dst, double_input);
-  ldgr(double_dst, dst);
-#if !V8_TARGET_ARCH_S390X
-  srlg(dst_hi, dst, Operand(32));
-#endif
 }
 
-void MacroAssembler::ConvertFloat32ToInt32(const DoubleRegister double_input,
-                                           const Register dst,
-                                           const DoubleRegister double_dst,
+void MacroAssembler::ConvertDoubleToInt32(const Register dst,
+                                          const DoubleRegister double_input,
+                                          FPRoundingMode rounding_mode) {
+  Condition m = Condition(0);
+  switch (rounding_mode) {
+    case kRoundToZero:
+      m = Condition(5);
+      break;
+    case kRoundToNearest:
+      m = Condition(4);
+      break;
+    case kRoundToPlusInf:
+      m = Condition(6);
+      break;
+    case kRoundToMinusInf:
+      m = Condition(7);
+      break;
+    default:
+      UNIMPLEMENTED();
+      break;
+  }
+  cfdbr(m, dst, double_input);
+}
+
+void MacroAssembler::ConvertFloat32ToInt32(const Register result,
+                                           const DoubleRegister double_input,
                                            FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       m = Condition(4);
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
-  cfebr(m, dst, double_input);
-  Label done;
-  b(Condition(0xe), &done, Label::kNear);  // special case
-  LoadImmP(dst, Operand::Zero());
-  bind(&done);
-  ldgr(double_dst, dst);
+  cfebr(m, result, double_input);
 }
 
 void MacroAssembler::ConvertFloat32ToUnsignedInt32(
-    const DoubleRegister double_input, const Register dst,
-    const DoubleRegister double_dst, FPRoundingMode rounding_mode) {
+    const Register result, const DoubleRegister double_input,
+    FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       UNIMPLEMENTED();
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
-  clfebr(m, Condition(0), dst, double_input);
-  Label done;
-  b(Condition(0xe), &done, Label::kNear);  // special case
-  LoadImmP(dst, Operand::Zero());
-  bind(&done);
-  ldgr(double_dst, dst);
+  clfebr(m, Condition(0), result, double_input);
 }
 
-#if V8_TARGET_ARCH_S390X
 void MacroAssembler::ConvertFloat32ToUnsignedInt64(
-    const DoubleRegister double_input, const Register dst,
-    const DoubleRegister double_dst, FPRoundingMode rounding_mode) {
+    const Register result, const DoubleRegister double_input,
+    FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       UNIMPLEMENTED();
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
-  clgebr(m, Condition(0), dst, double_input);
-  ldgr(double_dst, dst);
+  clgebr(m, Condition(0), result, double_input);
 }
 
 void MacroAssembler::ConvertDoubleToUnsignedInt64(
-    const DoubleRegister double_input, const Register dst,
-    const DoubleRegister double_dst, FPRoundingMode rounding_mode) {
+    const Register dst, const DoubleRegister double_input,
+    FPRoundingMode rounding_mode) {
   Condition m = Condition(0);
   switch (rounding_mode) {
     case kRoundToZero:
       m = Condition(5);
       break;
     case kRoundToNearest:
       UNIMPLEMENTED();
       break;
     case kRoundToPlusInf:
       m = Condition(6);
       break;
     case kRoundToMinusInf:
       m = Condition(7);
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
   clgdbr(m, Condition(0), dst, double_input);
-  ldgr(double_dst, dst);
 }
 
-#endif
+void MacroAssembler::ConvertDoubleToUnsignedInt32(
+    const Register dst, const DoubleRegister double_input,
+    FPRoundingMode rounding_mode) {
+  Condition m = Condition(0);
+  switch (rounding_mode) {
+    case kRoundToZero:
+      m = Condition(5);
+      break;
+    case kRoundToNearest:
+      UNIMPLEMENTED();
+      break;
+    case kRoundToPlusInf:
+      m = Condition(6);
+      break;
+    case kRoundToMinusInf:
+      m = Condition(7);
+      break;
+    default:
+      UNIMPLEMENTED();
+      break;
+  }
+  clfdbr(m, Condition(0), dst, double_input);
+}
 
 #if !V8_TARGET_ARCH_S390X
 void MacroAssembler::ShiftLeftPair(Register dst_low, Register dst_high,
                                    Register src_low, Register src_high,
                                    Register scratch, Register shift) {
   LoadRR(r0, src_high);
   LoadRR(r1, src_low);
   sldl(r0, shift, Operand::Zero());
   LoadRR(dst_high, r0);
   LoadRR(dst_low, r1);
@@ skipping 997 matching lines @@
   LoadlB(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
   CmpP(type_reg, Operand(type));
 }
 
 void MacroAssembler::CompareRoot(Register obj, Heap::RootListIndex index) {
   CmpP(obj, MemOperand(kRootRegister, index << kPointerSizeLog2));
 }
 
 void MacroAssembler::SmiToDouble(DoubleRegister value, Register smi) {
   SmiUntag(ip, smi);
-  ConvertIntToDouble(ip, value);
+  ConvertIntToDouble(value, ip);
 }
 
 void MacroAssembler::CompareMap(Register obj, Register scratch, Handle<Map> map,
                                 Label* early_success) {
   LoadP(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
   CompareMap(obj, map, early_success);
 }
 
 void MacroAssembler::CompareMap(Register obj_map, Handle<Map> map,
                                 Label* early_success) {
@@ skipping 104 matching lines @@
   Cmp32(scratch, Operand::Zero());
 }
 
 void MacroAssembler::TryDoubleToInt32Exact(Register result,
                                            DoubleRegister double_input,
                                            Register scratch,
                                            DoubleRegister double_scratch) {
   Label done;
   DCHECK(!double_input.is(double_scratch));
 
-  ConvertDoubleToInt64(double_input,
-#if !V8_TARGET_ARCH_S390X
-                       scratch,
-#endif
-                       result, double_scratch);
+  ConvertDoubleToInt64(result, double_input);
 
-#if V8_TARGET_ARCH_S390X
-  TestIfInt32(result, r0);
-#else
-  TestIfInt32(scratch, result, r0);
-#endif
+  TestIfInt32(result);
   bne(&done);
 
   // convert back and compare
-  lgdr(scratch, double_scratch);
-  cdfbr(double_scratch, scratch);
+  cdfbr(double_scratch, result);
   cdbr(double_scratch, double_input);
   bind(&done);
 }
 
 void MacroAssembler::TryInt32Floor(Register result, DoubleRegister double_input,
                                    Register input_high, Register scratch,
                                    DoubleRegister double_scratch, Label* done,
                                    Label* exact) {
   DCHECK(!result.is(input_high));
   DCHECK(!double_input.is(double_scratch));
   Label exception;
 
   // Move high word into input_high
   lay(sp, MemOperand(sp, -kDoubleSize));
   StoreDouble(double_input, MemOperand(sp));
   LoadlW(input_high, MemOperand(sp, Register::kExponentOffset));
   la(sp, MemOperand(sp, kDoubleSize));
 
   // Test for NaN/Inf
   ExtractBitMask(result, input_high, HeapNumber::kExponentMask);
   CmpLogicalP(result, Operand(0x7ff));
   beq(&exception);
 
   // Convert (rounding to -Inf)
-  ConvertDoubleToInt64(double_input,
-#if !V8_TARGET_ARCH_S390X
-                       scratch,
-#endif
-                       result, double_scratch, kRoundToMinusInf);
+  ConvertDoubleToInt64(result, double_input, kRoundToMinusInf);
 
-// Test for overflow
-#if V8_TARGET_ARCH_S390X
-  TestIfInt32(result, r0);
-#else
-  TestIfInt32(scratch, result, r0);
-#endif
+  // Test for overflow
+  TestIfInt32(result);
   bne(&exception);
 
   // Test for exactness
-  lgdr(scratch, double_scratch);
-  cdfbr(double_scratch, scratch);
+  cdfbr(double_scratch, result);
   cdbr(double_scratch, double_input);
   beq(exact);
   b(done);
 
   bind(&exception);
 }
 
 void MacroAssembler::TryInlineTruncateDoubleToI(Register result,
                                                 DoubleRegister double_input,
                                                 Label* done) {
-  DoubleRegister double_scratch = kScratchDoubleReg;
-#if !V8_TARGET_ARCH_S390X
-  Register scratch = ip;
-#endif
+  ConvertDoubleToInt64(result, double_input);
 
-  ConvertDoubleToInt64(double_input,
-#if !V8_TARGET_ARCH_S390X
-                       scratch,
-#endif
-                       result, double_scratch);
-
-// Test for overflow
-#if V8_TARGET_ARCH_S390X
-  TestIfInt32(result, r0);
-#else
-  TestIfInt32(scratch, result, r0);
-#endif
+  // Test for overflow
+  TestIfInt32(result);
   beq(done);
 }
 
 void MacroAssembler::TruncateDoubleToI(Register result,
                                        DoubleRegister double_input) {
   Label done;
 
   TryInlineTruncateDoubleToI(result, double_input, &done);
 
   // If we fell through then inline version didn't succeed - call stub instead.
@@ skipping 3363 matching lines @@
   }
   if (mag.shift > 0) ShiftRightArith(result, result, Operand(mag.shift));
   ExtractBit(r0, dividend, 31);
   AddP(result, r0);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_S390