Version 5.1.281.58 (cherry-pick)

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 187 matching lines @@
     LoadRR(dst, src);
   }
 }
 
 void MacroAssembler::Move(DoubleRegister dst, DoubleRegister src) {
   if (!dst.is(src)) {
     ldr(dst, src);
   }
 }
 
-void MacroAssembler::InsertDoubleLow(DoubleRegister dst, Register src) {
-  StoreDouble(dst, MemOperand(sp, -kDoubleSize));
-#if V8_TARGET_LITTLE_ENDIAN
-  StoreW(src, MemOperand(sp, -kDoubleSize));
-#else
-  StoreW(src, MemOperand(sp, -kDoubleSize / 2));
-#endif
-  ldy(dst, MemOperand(sp, -kDoubleSize));
-}
-
-void MacroAssembler::InsertDoubleHigh(DoubleRegister dst, Register src) {
-  StoreDouble(dst, MemOperand(sp, -kDoubleSize));
-#if V8_TARGET_LITTLE_ENDIAN
-  StoreW(src, MemOperand(sp, -kDoubleSize / 2));
-#else
-  StoreW(src, MemOperand(sp, -kDoubleSize));
-#endif
-  ldy(dst, MemOperand(sp, -kDoubleSize));
-}
-
 void MacroAssembler::MultiPush(RegList regs, Register location) {
   int16_t num_to_push = NumberOfBitsSet(regs);
   int16_t stack_offset = num_to_push * kPointerSize;
 
   SubP(location, location, Operand(stack_offset));
   for (int16_t i = Register::kNumRegisters - 1; i >= 0; i--) {
     if ((regs & (1 << i)) != 0) {
       stack_offset -= kPointerSize;
       StoreP(ToRegister(i), MemOperand(location, stack_offset));
     }
@@ skipping 868 matching lines @@
   lay(sp, MemOperand(sp, -stack_space * kPointerSize));
 
   // Allocate and align the frame preparing for calling the runtime
   // function.
   const int frame_alignment = MacroAssembler::ActivationFrameAlignment();
   if (frame_alignment > 0) {
     DCHECK(frame_alignment == 8);
     ClearRightImm(sp, sp, Operand(3));  // equivalent to &= -8
   }
 
-  StoreP(MemOperand(sp, -kNumRequiredStackFrameSlots * kPointerSize),
-         Operand::Zero(), r0);
   lay(sp, MemOperand(sp, -kNumRequiredStackFrameSlots * kPointerSize));
+  StoreP(MemOperand(sp), Operand::Zero(), r0);
   // Set the exit frame sp value to point just before the return address
   // location.
   lay(r1, MemOperand(sp, kStackFrameSPSlot * kPointerSize));
   StoreP(r1, MemOperand(fp, ExitFrameConstants::kSPOffset));
 }
 
 void MacroAssembler::InitializeNewString(Register string, Register length,
                                          Heap::RootListIndex map_index,
                                          Register scratch1, Register scratch2) {
   SmiTag(scratch1, length);
@@ skipping 1196 matching lines @@
   CmpP(scratch1, Operand::Zero());
   bne(&done, Label::kNear);
 
   srlg(scratch1, scratch1, Operand(32));
   CmpP(scratch1, Operand(HeapNumber::kSignMask));
   bind(&done);
 #endif
 }
 
 void MacroAssembler::TestDoubleSign(DoubleRegister input, Register scratch) {
-  stdy(input, MemOperand(sp, -kDoubleSize));
-  LoadlW(scratch, MemOperand(sp, -kDoubleSize + Register::kExponentOffset));
-  Cmp32(scratch, Operand::Zero());
+  lgdr(scratch, input);
+  cgfi(scratch, Operand::Zero());
 }
 
 void MacroAssembler::TestHeapNumberSign(Register input, Register scratch) {
   LoadlW(scratch, FieldMemOperand(input, HeapNumber::kValueOffset +
                                              Register::kExponentOffset));
   Cmp32(scratch, Operand::Zero());
 }
 
 void MacroAssembler::TryDoubleToInt32Exact(Register result,
                                            DoubleRegister double_input,
@@ skipping 24 matching lines @@
 
 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
-  StoreDouble(double_input, MemOperand(sp, -kDoubleSize));
   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,
@@ skipping 45 matching lines @@
 
 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.
   push(r14);
   // Put input on stack.
-  StoreDouble(double_input, MemOperand(sp, -kDoubleSize));
   lay(sp, MemOperand(sp, -kDoubleSize));
+  StoreDouble(double_input, MemOperand(sp));
 
   DoubleToIStub stub(isolate(), sp, result, 0, true, true);
   CallStub(&stub);
 
   la(sp, MemOperand(sp, kDoubleSize));
   pop(r14);
 
   bind(&done);
 }
 
@@ skipping 2755 matching lines @@
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     srlk(dst, src, val);
   } else {
     lr(dst, src);
     srl(dst, val);
   }
 }
 
 // Shift right logical for 32-bit integer types.
 void MacroAssembler::ShiftRight(Register dst, Register src, Register val) {
-  DCHECK(!dst.is(val));  // The lr/srl path clobbers val.
   if (dst.is(src)) {
     srl(dst, val);
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     srlk(dst, src, val);
   } else {
+    DCHECK(!dst.is(val));  // The lr/srl path clobbers val.
     lr(dst, src);
     srl(dst, val);
   }
 }
 
 // Shift left arithmetic for 32-bit integer types.
 void MacroAssembler::ShiftLeftArith(Register dst, Register src,
                                     const Operand& val) {
   if (dst.is(src)) {
     sla(dst, val);
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     slak(dst, src, val);
   } else {
     lr(dst, src);
     sla(dst, val);
   }
 }
 
 // Shift left arithmetic for 32-bit integer types.
 void MacroAssembler::ShiftLeftArith(Register dst, Register src, Register val) {
-  DCHECK(!dst.is(val));  // The lr/sla path clobbers val.
   if (dst.is(src)) {
     sla(dst, val);
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     slak(dst, src, val);
   } else {
+    DCHECK(!dst.is(val));  // The lr/sla path clobbers val.
     lr(dst, src);
     sla(dst, val);
   }
 }
 
 // Shift right arithmetic for 32-bit integer types.
 void MacroAssembler::ShiftRightArith(Register dst, Register src,
                                      const Operand& val) {
   if (dst.is(src)) {
     sra(dst, val);
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     srak(dst, src, val);
   } else {
     lr(dst, src);
     sra(dst, val);
   }
 }
 
 // Shift right arithmetic for 32-bit integer types.
 void MacroAssembler::ShiftRightArith(Register dst, Register src, Register val) {
-  DCHECK(!dst.is(val));  // The lr/sra path clobbers val.
   if (dst.is(src)) {
     sra(dst, val);
   } else if (CpuFeatures::IsSupported(DISTINCT_OPS)) {
     srak(dst, src, val);
   } else {
+    DCHECK(!dst.is(val));  // The lr/sra path clobbers val.
     lr(dst, src);
     sra(dst, val);
   }
 }
 
 // Clear right most # of bits
 void MacroAssembler::ClearRightImm(Register dst, Register src,
                                    const Operand& val) {
   int numBitsToClear = val.imm_ % (kPointerSize * 8);
 
@@ skipping 128 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