s390x: cleanup StoreXXX as std

a few unused functions

Drive-By: Also clean up LoadSimd128 as LoadV128 and remove
Change-Id: I4cdee0fcb1e153309492026b4334af27afba7ec1
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2584442
Commit-Queue: Junliang Yan <junyan@redhat.com>
Reviewed-by: Milad Fa <mfarazma@redhat.com>
Cr-Commit-Position: refs/heads/master@{#71701}

src/codegen/s390/macro-assembler-s390.h

@@ -284,9 +284,6 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
   // Add Logical (Register - Register)
   void AddLogical32(Register dst, Register src1, Register src2);
 
-  // Add Logical With Carry (Register - Register)
-  void AddLogicalWithCarry32(Register dst, Register src1, Register src2);
-
   // Add Logical (Register - Immediate)
   void AddLogical(Register dst, const Operand& imm);
   void AddLogicalP(Register dst, const Operand& imm);
@@ -297,12 +294,8 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
 
   // Subtract (Register - Immediate)
   void Sub32(Register dst, const Operand& imm);
-  void Sub32_RI(Register dst, const Operand& imm) { Sub32(dst, imm); }
   void SubP(Register dst, const Operand& imm);
   void Sub32(Register dst, Register src, const Operand& imm);
-  void Sub32_RRI(Register dst, Register src, const Operand& imm) {
-    Sub32(dst, src, imm);
-  }
   void SubP(Register dst, Register src, const Operand& imm);
 
   // Subtract (Register - Register)
@@ -326,8 +319,6 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
   void SubLogicalP_ExtendSrc(Register dst, const MemOperand& opnd);
   // Subtract Logical 32-bit
   void SubLogical32(Register dst, Register src1, Register src2);
-  // Subtract Logical With Borrow 32-bit
-  void SubLogicalWithBorrow32(Register dst, Register src1, Register src2);
 
   // Multiply
   void MulP(Register dst, const Operand& opnd);
@@ -427,9 +418,7 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
   // Load Floating Point
   void LoadF64(DoubleRegister dst, const MemOperand& opnd);
   void LoadF32(DoubleRegister dst, const MemOperand& opnd);
-  void LoadFloat32ConvertToDouble(DoubleRegister dst, const MemOperand& mem);
-  void LoadSimd128(Simd128Register dst, const MemOperand& mem,
-                   Register scratch);
+  void LoadV128(Simd128Register dst, const MemOperand& mem, Register scratch);
 
   void AddFloat32(DoubleRegister dst, const MemOperand& opnd,
                   DoubleRegister scratch);
@@ -447,8 +436,8 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
                   DoubleRegister scratch);
   void DivFloat64(DoubleRegister dst, const MemOperand& opnd,
                   DoubleRegister scratch);
-  void LoadFloat32ToDouble(DoubleRegister dst, const MemOperand& opnd,
-                           DoubleRegister scratch);
+  void LoadF32AsF64(DoubleRegister dst, const MemOperand& opnd,
+                    DoubleRegister scratch);
 
   // Load On Condition
   void LoadOnConditionP(Condition cond, Register dst, Register src);
@@ -457,12 +446,9 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
   void LoadPositive32(Register result, Register input);
 
   // Store Floating Point
-  void StoreDouble(DoubleRegister dst, const MemOperand& opnd);
-  void StoreFloat32(DoubleRegister dst, const MemOperand& opnd);
-  void StoreDoubleAsFloat32(DoubleRegister src, const MemOperand& mem,
-                            DoubleRegister scratch);
-  void StoreSimd128(Simd128Register src, const MemOperand& mem,
-                    Register scratch);
+  void StoreF64(DoubleRegister dst, const MemOperand& opnd);
+  void StoreF32(DoubleRegister dst, const MemOperand& opnd);
+  void StoreV128(Simd128Register src, const MemOperand& mem, Register scratch);
 
   void Branch(Condition c, const Operand& opnd);
   void BranchOnCount(Register r1, Label* l);
@@ -529,12 +515,12 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
 
   void push(DoubleRegister src) {
     lay(sp, MemOperand(sp, -kSystemPointerSize));
-    StoreDouble(src, MemOperand(sp));
+    StoreF64(src, MemOperand(sp));
   }
 
   void push(Register src) {
     lay(sp, MemOperand(sp, -kSystemPointerSize));
-    StoreP(src, MemOperand(sp));
+    StoreU64(src, MemOperand(sp));
   }
 
   void pop(DoubleRegister dst) {
@@ -558,25 +544,25 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
   // Push two registers.  Pushes leftmost register first (to highest address).
   void Push(Register src1, Register src2) {
     lay(sp, MemOperand(sp, -kSystemPointerSize * 2));
-    StoreP(src1, MemOperand(sp, kSystemPointerSize));
-    StoreP(src2, MemOperand(sp, 0));
+    StoreU64(src1, MemOperand(sp, kSystemPointerSize));
+    StoreU64(src2, MemOperand(sp, 0));
   }
 
   // Push three registers.  Pushes leftmost register first (to highest address).
   void Push(Register src1, Register src2, Register src3) {
     lay(sp, MemOperand(sp, -kSystemPointerSize * 3));
-    StoreP(src1, MemOperand(sp, kSystemPointerSize * 2));
-    StoreP(src2, MemOperand(sp, kSystemPointerSize));
-    StoreP(src3, MemOperand(sp, 0));
+    StoreU64(src1, MemOperand(sp, kSystemPointerSize * 2));
+    StoreU64(src2, MemOperand(sp, kSystemPointerSize));
+    StoreU64(src3, MemOperand(sp, 0));
   }
 
   // Push four registers.  Pushes leftmost register first (to highest address).
   void Push(Register src1, Register src2, Register src3, Register src4) {
     lay(sp, MemOperand(sp, -kSystemPointerSize * 4));
-    StoreP(src1, MemOperand(sp, kSystemPointerSize * 3));
-    StoreP(src2, MemOperand(sp, kSystemPointerSize * 2));
-    StoreP(src3, MemOperand(sp, kSystemPointerSize));
-    StoreP(src4, MemOperand(sp, 0));
+    StoreU64(src1, MemOperand(sp, kSystemPointerSize * 3));
+    StoreU64(src2, MemOperand(sp, kSystemPointerSize * 2));
+    StoreU64(src3, MemOperand(sp, kSystemPointerSize));
+    StoreU64(src4, MemOperand(sp, 0));
   }
 
   // Push five registers.  Pushes leftmost register first (to highest address).
@@ -594,11 +580,11 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
     DCHECK(src4 != src5);
 
     lay(sp, MemOperand(sp, -kSystemPointerSize * 5));
-    StoreP(src1, MemOperand(sp, kSystemPointerSize * 4));
-    StoreP(src2, MemOperand(sp, kSystemPointerSize * 3));
-    StoreP(src3, MemOperand(sp, kSystemPointerSize * 2));
-    StoreP(src4, MemOperand(sp, kSystemPointerSize));
-    StoreP(src5, MemOperand(sp, 0));
+    StoreU64(src1, MemOperand(sp, kSystemPointerSize * 4));
+    StoreU64(src2, MemOperand(sp, kSystemPointerSize * 3));
+    StoreU64(src3, MemOperand(sp, kSystemPointerSize * 2));
+    StoreU64(src4, MemOperand(sp, kSystemPointerSize));
+    StoreU64(src5, MemOperand(sp, 0));
   }
 
   enum PushArrayOrder { kNormal, kReverse };
@@ -748,16 +734,15 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
 
   void LoadFloat32Literal(DoubleRegister result, float value, Register scratch);
 
-  void StoreW(Register src, const MemOperand& mem, Register scratch = no_reg);
+  void StoreU32(Register src, const MemOperand& mem, Register scratch = no_reg);
 
   void LoadS16(Register dst, Register src);
 
   void LoadS16(Register dst, const MemOperand& mem,
                      Register scratch = no_reg);
 
-  void StoreHalfWord(Register src, const MemOperand& mem,
-                     Register scratch = r0);
-  void StoreByte(Register src, const MemOperand& mem, Register scratch = r0);
+  void StoreU16(Register src, const MemOperand& mem, Register scratch = r0);
+  void StoreU8(Register src, const MemOperand& mem, Register scratch = r0);
   void CmpSmiLiteral(Register src1, Smi smi, Register scratch);
 
   // Set new rounding mode RN to FPSCR
@@ -768,9 +753,9 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
 
   // These exist to provide portability between 32 and 64bit
   void LoadP(Register dst, const MemOperand& mem, Register scratch = no_reg);
-  void StoreP(Register src, const MemOperand& mem, Register scratch = no_reg);
-  void StoreP(const MemOperand& mem, const Operand& opnd,
-              Register scratch = no_reg);
+  void StoreU64(Register src, const MemOperand& mem, Register scratch = no_reg);
+  void StoreU64(const MemOperand& mem, const Operand& opnd,
+                Register scratch = no_reg);
   void LoadMultipleP(Register dst1, Register dst2, const MemOperand& mem);
   void StoreMultipleP(Register dst1, Register dst2, const MemOperand& mem);
   void LoadMultipleW(Register dst1, Register dst2, const MemOperand& mem);
@@ -1069,7 +1054,7 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
   }
 
   void StoreReceiver(Register rec, Register argc, Register scratch) {
-    StoreP(rec, MemOperand(sp, 0));
+    StoreU64(rec, MemOperand(sp, 0));
   }
 
   void CallRuntime(const Runtime::Function* f, int num_arguments,

src/regexp/s390/regexp-macro-assembler-s390.cc

@@ -160,7 +160,7 @@ void RegExpMacroAssemblerS390::AdvanceRegister(int reg, int by) {
       __ LoadP(r2, register_location(reg), r0);
       __ mov(r0, Operand(by));
       __ AddRR(r2, r0);
-      __ StoreP(r2, register_location(reg));
+      __ StoreU64(r2, register_location(reg));
     }
   }
 }
@@ -171,7 +171,7 @@ void RegExpMacroAssemblerS390::Backtrack() {
     Label next;
     __ LoadP(r2, MemOperand(frame_pointer(), kBacktrackCount), r0);
     __ AddP(r2, r2, Operand(1));
-    __ StoreP(r2, MemOperand(frame_pointer(), kBacktrackCount), r0);
+    __ StoreU64(r2, MemOperand(frame_pointer(), kBacktrackCount), r0);
     __ CmpLogicalP(r2, Operand(backtrack_limit()));
     __ bne(&next);
 
@@ -733,7 +733,7 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
   }
   // Store this value in a local variable, for use when clearing
   // position registers.
-  __ StoreP(r1, MemOperand(frame_pointer(), kStringStartMinusOne));
+  __ StoreU64(r1, MemOperand(frame_pointer(), kStringStartMinusOne));
 
   // Initialize code pointer register
   __ mov(code_pointer(), Operand(masm_->CodeObject()));
@@ -761,12 +761,12 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
       __ Load(r4, Operand(num_saved_registers_));
       Label init_loop;
       __ bind(&init_loop);
-      __ StoreP(r1, MemOperand(r3, -kSystemPointerSize));
+      __ StoreU64(r1, MemOperand(r3, -kSystemPointerSize));
       __ lay(r3, MemOperand(r3, -kSystemPointerSize));
       __ BranchOnCount(r4, &init_loop);
     } else {
       for (int i = 0; i < num_saved_registers_; i++) {
-        __ StoreP(r1, register_location(i));
+        __ StoreU64(r1, register_location(i));
       }
     }
   }
@@ -814,13 +814,14 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
           __ AddP(r4, r0);
           __ AddP(r5, r0);
           __ AddP(r6, r0);
-          __ StoreW(r3,
-                    MemOperand(r2, -(num_saved_registers_ - i - 3) * kIntSize));
-          __ StoreW(r4,
-                    MemOperand(r2, -(num_saved_registers_ - i - 2) * kIntSize));
-          __ StoreW(r5,
-                    MemOperand(r2, -(num_saved_registers_ - i - 1) * kIntSize));
-          __ StoreW(r6, MemOperand(r2, -(num_saved_registers_ - i) * kIntSize));
+          __ StoreU32(
+              r3, MemOperand(r2, -(num_saved_registers_ - i - 3) * kIntSize));
+          __ StoreU32(
+              r4, MemOperand(r2, -(num_saved_registers_ - i - 2) * kIntSize));
+          __ StoreU32(
+              r5, MemOperand(r2, -(num_saved_registers_ - i - 1) * kIntSize));
+          __ StoreU32(r6,
+                      MemOperand(r2, -(num_saved_registers_ - i) * kIntSize));
           i += 4;
         } else {
           __ LoadMultipleP(r3, r4, register_location(i + 1));
@@ -830,9 +831,10 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
           }
           __ AddP(r3, r0);
           __ AddP(r4, r0);
-          __ StoreW(r3,
-                    MemOperand(r2, -(num_saved_registers_ - i - 1) * kIntSize));
-          __ StoreW(r4, MemOperand(r2, -(num_saved_registers_ - i) * kIntSize));
+          __ StoreU32(
+              r3, MemOperand(r2, -(num_saved_registers_ - i - 1) * kIntSize));
+          __ StoreU32(r4,
+                      MemOperand(r2, -(num_saved_registers_ - i) * kIntSize));
           i += 2;
         }
       }
@@ -849,7 +851,7 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
       __ LoadP(r4, MemOperand(frame_pointer(), kRegisterOutput));
       // Increment success counter.
       __ AddP(r2, Operand(1));
-      __ StoreP(r2, MemOperand(frame_pointer(), kSuccessfulCaptures));
+      __ StoreU64(r2, MemOperand(frame_pointer(), kSuccessfulCaptures));
       // Capture results have been stored, so the number of remaining global
       // output registers is reduced by the number of stored captures.
       __ SubP(r3, Operand(num_saved_registers_));
@@ -857,10 +859,10 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
       __ CmpP(r3, Operand(num_saved_registers_));
       __ blt(&return_r2);
 
-      __ StoreP(r3, MemOperand(frame_pointer(), kNumOutputRegisters));
+      __ StoreU64(r3, MemOperand(frame_pointer(), kNumOutputRegisters));
       // Advance the location for output.
       __ AddP(r4, Operand(num_saved_registers_ * kIntSize));
-      __ StoreP(r4, MemOperand(frame_pointer(), kRegisterOutput));
+      __ StoreU64(r4, MemOperand(frame_pointer(), kRegisterOutput));
 
       // Prepare r2 to initialize registers with its value in the next run.
       __ LoadP(r2, MemOperand(frame_pointer(), kStringStartMinusOne));
@@ -1005,7 +1007,7 @@ void RegExpMacroAssemblerS390::PopCurrentPosition() {
 
 void RegExpMacroAssemblerS390::PopRegister(int register_index) {
   Pop(r2);
-  __ StoreP(r2, register_location(register_index));
+  __ StoreU64(r2, register_location(register_index));
 }
 
 void RegExpMacroAssemblerS390::PushBacktrack(Label* label) {
@@ -1055,7 +1057,7 @@ void RegExpMacroAssemblerS390::SetCurrentPositionFromEnd(int by) {
 void RegExpMacroAssemblerS390::SetRegister(int register_index, int to) {
   DCHECK(register_index >= num_saved_registers_);  // Reserved for positions!
   __ mov(r2, Operand(to));
-  __ StoreP(r2, register_location(register_index));
+  __ StoreU64(r2, register_location(register_index));
 }
 
 bool RegExpMacroAssemblerS390::Succeed() {
@@ -1066,10 +1068,10 @@ bool RegExpMacroAssemblerS390::Succeed() {
 void RegExpMacroAssemblerS390::WriteCurrentPositionToRegister(int reg,
                                                               int cp_offset) {
   if (cp_offset == 0) {
-    __ StoreP(current_input_offset(), register_location(reg));
+    __ StoreU64(current_input_offset(), register_location(reg));
   } else {
     __ AddP(r2, current_input_offset(), Operand(cp_offset * char_size()));
-    __ StoreP(r2, register_location(reg));
+    __ StoreU64(r2, register_location(reg));
   }
 }
 
@@ -1077,14 +1079,14 @@ void RegExpMacroAssemblerS390::ClearRegisters(int reg_from, int reg_to) {
   DCHECK(reg_from <= reg_to);
   __ LoadP(r2, MemOperand(frame_pointer(), kStringStartMinusOne));
   for (int reg = reg_from; reg <= reg_to; reg++) {
-    __ StoreP(r2, register_location(reg));
+    __ StoreU64(r2, register_location(reg));
   }
 }
 
 void RegExpMacroAssemblerS390::WriteStackPointerToRegister(int reg) {
   __ LoadP(r3, MemOperand(frame_pointer(), kStackHighEnd));
   __ SubP(r2, backtrack_stackpointer(), r3);
-  __ StoreP(r2, register_location(reg));
+  __ StoreU64(r2, register_location(reg));
 }
 
 // Private methods:
@@ -1216,7 +1218,7 @@ void RegExpMacroAssemblerS390::Push(Register source) {
   DCHECK(source != backtrack_stackpointer());
   __ lay(backtrack_stackpointer(),
          MemOperand(backtrack_stackpointer(), -kSystemPointerSize));
-  __ StoreP(source, MemOperand(backtrack_stackpointer()));
+  __ StoreU64(source, MemOperand(backtrack_stackpointer()));
 }
 
 void RegExpMacroAssemblerS390::Pop(Register target) {
@@ -1250,7 +1252,7 @@ void RegExpMacroAssemblerS390::CallCFunctionUsingStub(
   __ mov(code_pointer(), Operand(function));
   Label ret;
   __ larl(r14, &ret);
-  __ StoreP(r14, MemOperand(sp, kStackFrameRASlot * kSystemPointerSize));
+  __ StoreU64(r14, MemOperand(sp, kStackFrameRASlot * kSystemPointerSize));
   __ b(code_pointer());
   __ bind(&ret);
   if (base::OS::ActivationFrameAlignment() > kSystemPointerSize) {

src/wasm/baseline/s390/liftoff-assembler-s390.h

@@ -295,11 +295,11 @@ void LiftoffAssembler::FillStackSlotsWithZero(int start, int size) {
     // instructions per slot.
     uint32_t remainder = size;
     for (; remainder >= kStackSlotSize; remainder -= kStackSlotSize) {
-      StoreP(r0, liftoff::GetStackSlot(start + remainder));
+      StoreU64(r0, liftoff::GetStackSlot(start + remainder));
     }
     DCHECK(remainder == 4 || remainder == 0);
     if (remainder) {
-      StoreW(r0, liftoff::GetStackSlot(start + remainder));
+      StoreU32(r0, liftoff::GetStackSlot(start + remainder));
     }
   } else {
     // General case for bigger counts (9 instructions).
@@ -311,7 +311,7 @@ void LiftoffAssembler::FillStackSlotsWithZero(int start, int size) {
 
     Label loop;
     bind(&loop);
-    StoreP(r0, MemOperand(r0));
+    StoreU64(r0, MemOperand(r0));
     la(r0, MemOperand(r0, kSystemPointerSize));
     CmpLogicalP(r3, r4);
     bne(&loop);