s390: improve floating point and integer convertion

src/crankshaft/s390/lithium-codegen-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 "src/crankshaft/s390/lithium-codegen-s390.h"
 
 #include "src/base/bits.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-factory.h"
@@ skipping 1342 matching lines @@
       case -1:
         if (can_overflow) {
 #if V8_TARGET_ARCH_S390X
           if (instr->hydrogen()->representation().IsSmi()) {
 #endif
             __ LoadComplementRR(result, left);
             DeoptimizeIf(overflow, instr, DeoptimizeReason::kOverflow);
 #if V8_TARGET_ARCH_S390X
           } else {
             __ LoadComplementRR(result, left);
-            __ TestIfInt32(result, r0);
+            __ TestIfInt32(result);
             DeoptimizeIf(ne, instr, DeoptimizeReason::kOverflow);
           }
 #endif
         } else {
           __ LoadComplementRR(result, left);
         }
         break;
       case 0:
         if (bailout_on_minus_zero) {
 // If left is strictly negative and the constant is null, the
@@ skipping 64 matching lines @@
 #if V8_TARGET_ARCH_S390X
         // result = left * right.
         if (instr->hydrogen()->representation().IsSmi()) {
           __ SmiUntag(result, left);
           __ SmiUntag(scratch, right);
           __ msgr(result, scratch);
         } else {
           __ LoadRR(result, left);
           __ msgr(result, right);
         }
-        __ TestIfInt32(result, r0);
+        __ TestIfInt32(result);
         DeoptimizeIf(ne, instr, DeoptimizeReason::kOverflow);
         if (instr->hydrogen()->representation().IsSmi()) {
           __ SmiTag(result);
         }
 #else
         // r0:scratch = scratch * right
         if (instr->hydrogen()->representation().IsSmi()) {
-          __ SmiUntag(scratch, left);
-          __ mr_z(r0, right);
-          __ LoadRR(result, scratch);
+          __ SmiUntag(result, left);
+          __ lgfr(result, result);
+          __ msgfr(result, right);
         } else {
           // r0:scratch = scratch * right
-          __ LoadRR(scratch, left);
-          __ mr_z(r0, right);
-          __ LoadRR(result, scratch);
+          __ lgfr(result, left);
+          __ msgfr(result, right);
         }
-        __ TestIfInt32(r0, result, scratch);
+        __ TestIfInt32(result);
         DeoptimizeIf(ne, instr, DeoptimizeReason::kOverflow);
 #endif
       }
     } else {
       if (instr->hydrogen()->representation().IsSmi()) {
         __ SmiUntag(result, left);
         __ Mul(result, result, right);
       } else {
         __ Mul(result, left, right);
       }
@@ skipping 2944 matching lines @@
 }
 
 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
   LOperand* input = instr->value();
   DCHECK(input->IsRegister() || input->IsStackSlot());
   LOperand* output = instr->result();
   DCHECK(output->IsDoubleRegister());
   if (input->IsStackSlot()) {
     Register scratch = scratch0();
     __ LoadP(scratch, ToMemOperand(input));
-    __ ConvertIntToDouble(scratch, ToDoubleRegister(output));
+    __ ConvertIntToDouble(ToDoubleRegister(output), scratch);
   } else {
-    __ ConvertIntToDouble(ToRegister(input), ToDoubleRegister(output));
+    __ ConvertIntToDouble(ToDoubleRegister(output), ToRegister(input));
   }
 }
 
 void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
   LOperand* input = instr->value();
   LOperand* output = instr->result();
-  __ ConvertUnsignedIntToDouble(ToRegister(input), ToDoubleRegister(output));
+  __ ConvertUnsignedIntToDouble(ToDoubleRegister(output), ToRegister(input));
 }
 
 void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
   class DeferredNumberTagI final : public LDeferredCode {
    public:
     DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
         : LDeferredCode(codegen), instr_(instr) {}
     void Generate() override {
       codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
                                        instr_->temp2(), SIGNED_INT32);
@@ skipping 55 matching lines @@
   DoubleRegister dbl_scratch = double_scratch0();
 
   if (signedness == SIGNED_INT32) {
     // There was overflow, so bits 30 and 31 of the original integer
     // disagree. Try to allocate a heap number in new space and store
     // the value in there. If that fails, call the runtime system.
     if (dst.is(src)) {
       __ SmiUntag(src, dst);
       __ xilf(src, Operand(HeapNumber::kSignMask));
     }
-    __ ConvertIntToDouble(src, dbl_scratch);
+    __ ConvertIntToDouble(dbl_scratch, src);
   } else {
-    __ ConvertUnsignedIntToDouble(src, dbl_scratch);
+    __ ConvertUnsignedIntToDouble(dbl_scratch, src);
   }
 
   if (FLAG_inline_new) {
     __ LoadRoot(tmp3, Heap::kHeapNumberMapRootIndex);
     __ AllocateHeapNumber(dst, tmp1, tmp2, tmp3, &slow);
     __ b(&done);
   }
 
   // Slow case: Call the runtime system to do the number allocation.
   __ bind(&slow);
@@ skipping 144 matching lines @@
                     FieldMemOperand(scratch, HeapNumber::kValueOffset));
       __ b(&done, Label::kNear);
     }
   } else {
     __ SmiUntag(scratch, input_reg);
     DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);
   }
   // Smi to double register conversion
   __ bind(&load_smi);
   // scratch: untagged value of input_reg
-  __ ConvertIntToDouble(scratch, result_reg);
+  __ ConvertIntToDouble(result_reg, scratch);
   __ bind(&done);
 }
 
 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
   Register input_reg = ToRegister(instr->value());
   Register scratch1 = scratch0();
   Register scratch2 = ToRegister(instr->temp());
   DoubleRegister double_scratch = double_scratch0();
   DoubleRegister double_scratch2 = ToDoubleRegister(instr->temp2());
 
@@ skipping 857 matching lines @@
   __ LoadP(result,
            FieldMemOperand(scratch, FixedArray::kHeaderSize - kPointerSize));
   __ bind(deferred->exit());
   __ bind(&done);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8