Unify some PlatformCodeStubs.

src/arm64/code-stubs-arm64.cc

 // Copyright 2013 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/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 612 matching lines @@
 
   // Check for both being sequential ASCII strings, and inline if that is the
   // case.
   __ Bind(&flat_string_check);
   __ JumpIfBothInstanceTypesAreNotSequentialAscii(lhs_type, rhs_type, x14,
                                                   x15, &slow);
 
   __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, x10,
                       x11);
   if (cond == eq) {
-    StringCompareStub::GenerateFlatAsciiStringEquals(masm, lhs, rhs,
-                                                     x10, x11, x12);
+    StringHelper::GenerateFlatAsciiStringEquals(masm, lhs, rhs, x10, x11, x12);
   } else {
-    StringCompareStub::GenerateCompareFlatAsciiStrings(masm, lhs, rhs,
-                                                       x10, x11, x12, x13);
+    StringHelper::GenerateCompareFlatAsciiStrings(masm, lhs, rhs, x10, x11, x12,
+                                                  x13);
   }
 
   // Never fall through to here.
   if (FLAG_debug_code) {
     __ Unreachable();
   }
 
   __ Bind(&slow);
 
   __ Push(lhs, rhs);
@@ skipping 29 matching lines @@
 
   // We don't allow a GC during a store buffer overflow so there is no need to
   // store the registers in any particular way, but we do have to store and
   // restore them.
 
   // We don't care if MacroAssembler scratch registers are corrupted.
   saved_regs.Remove(*(masm->TmpList()));
   saved_fp_regs.Remove(*(masm->FPTmpList()));
 
   __ PushCPURegList(saved_regs);
-  if (save_doubles_ == kSaveFPRegs) {
+  if (save_doubles()) {
     __ PushCPURegList(saved_fp_regs);
   }
 
   AllowExternalCallThatCantCauseGC scope(masm);
   __ Mov(x0, ExternalReference::isolate_address(isolate()));
   __ CallCFunction(
       ExternalReference::store_buffer_overflow_function(isolate()), 1, 0);
 
-  if (save_doubles_ == kSaveFPRegs) {
+  if (save_doubles()) {
     __ PopCPURegList(saved_fp_regs);
   }
   __ PopCPURegList(saved_regs);
   __ Ret();
 }
 
 
 void StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(
     Isolate* isolate) {
   StoreBufferOverflowStub stub1(isolate, kDontSaveFPRegs);
@@ skipping 2716 matching lines @@
     __ Bind(&not_internalized_strings);
   }
 
   // Check that both strings are sequential ASCII.
   Label runtime;
   __ JumpIfBothInstanceTypesAreNotSequentialAscii(
       lhs_type, rhs_type, x12, x13, &runtime);
 
   // Compare flat ASCII strings. Returns when done.
   if (equality) {
-    StringCompareStub::GenerateFlatAsciiStringEquals(
-        masm, lhs, rhs, x10, x11, x12);
+    StringHelper::GenerateFlatAsciiStringEquals(masm, lhs, rhs, x10, x11, x12);
   } else {
-    StringCompareStub::GenerateCompareFlatAsciiStrings(
-        masm, lhs, rhs, x10, x11, x12, x13);
+    StringHelper::GenerateCompareFlatAsciiStrings(masm, lhs, rhs, x10, x11, x12,
+                                                  x13);
   }
 
   // Handle more complex cases in runtime.
   __ Bind(&runtime);
   __ Push(lhs, rhs);
   if (equality) {
     __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
   } else {
     __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
   }
@@ skipping 396 matching lines @@
   StringCharAtGenerator generator(
       input_string, from, result_length, x0,
       &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
   generator.GenerateFast(masm);
   __ Drop(3);
   __ Ret();
   generator.SkipSlow(masm, &runtime);
 }
 
 
-void StringCompareStub::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
-                                                      Register left,
-                                                      Register right,
-                                                      Register scratch1,
-                                                      Register scratch2,
-                                                      Register scratch3) {
+void StringHelper::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
+                                                 Register left, Register right,
+                                                 Register scratch1,
+                                                 Register scratch2,
+                                                 Register scratch3) {
   DCHECK(!AreAliased(left, right, scratch1, scratch2, scratch3));
   Register result = x0;
   Register left_length = scratch1;
   Register right_length = scratch2;
 
   // Compare lengths. If lengths differ, strings can't be equal. Lengths are
   // smis, and don't need to be untagged.
   Label strings_not_equal, check_zero_length;
   __ Ldr(left_length, FieldMemOperand(left, String::kLengthOffset));
   __ Ldr(right_length, FieldMemOperand(right, String::kLengthOffset));
@@ skipping 16 matching lines @@
   __ Bind(&compare_chars);
   GenerateAsciiCharsCompareLoop(masm, left, right, left_length, scratch2,
                                 scratch3, &strings_not_equal);
 
   // Characters in strings are equal.
   __ Mov(result, Smi::FromInt(EQUAL));
   __ Ret();
 }
 
 
-void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
-                                                        Register left,
-                                                        Register right,
-                                                        Register scratch1,
-                                                        Register scratch2,
-                                                        Register scratch3,
-                                                        Register scratch4) {
+void StringHelper::GenerateCompareFlatAsciiStrings(
+    MacroAssembler* masm, Register left, Register right, Register scratch1,
+    Register scratch2, Register scratch3, Register scratch4) {
   DCHECK(!AreAliased(left, right, scratch1, scratch2, scratch3, scratch4));
   Label result_not_equal, compare_lengths;
 
   // Find minimum length and length difference.
   Register length_delta = scratch3;
   __ Ldr(scratch1, FieldMemOperand(left, String::kLengthOffset));
   __ Ldr(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ Subs(length_delta, scratch1, scratch2);
 
   Register min_length = scratch1;
@@ skipping 18 matching lines @@
   Register greater = x10;
   Register less = x11;
   __ Mov(greater, Smi::FromInt(GREATER));
   __ Mov(less, Smi::FromInt(LESS));
   __ CmovX(result, greater, gt);
   __ CmovX(result, less, lt);
   __ Ret();
 }
 
 
-void StringCompareStub::GenerateAsciiCharsCompareLoop(
-    MacroAssembler* masm,
-    Register left,
-    Register right,
-    Register length,
-    Register scratch1,
-    Register scratch2,
-    Label* chars_not_equal) {
+void StringHelper::GenerateAsciiCharsCompareLoop(
+    MacroAssembler* masm, Register left, Register right, Register length,
+    Register scratch1, Register scratch2, Label* chars_not_equal) {
   DCHECK(!AreAliased(left, right, length, scratch1, scratch2));
 
   // Change index to run from -length to -1 by adding length to string
   // start. This means that loop ends when index reaches zero, which
   // doesn't need an additional compare.
   __ SmiUntag(length);
   __ Add(scratch1, length, SeqOneByteString::kHeaderSize - kHeapObjectTag);
   __ Add(left, left, scratch1);
   __ Add(right, right, scratch1);
 
@@ skipping 33 matching lines @@
   __ Ret();
 
   __ Bind(&not_same);
 
   // Check that both objects are sequential ASCII strings.
   __ JumpIfEitherIsNotSequentialAsciiStrings(left, right, x12, x13, &runtime);
 
   // Compare flat ASCII strings natively. Remove arguments from stack first,
   // as this function will generate a return.
   __ IncrementCounter(counters->string_compare_native(), 1, x3, x4);
-  GenerateCompareFlatAsciiStrings(masm, left, right, x12, x13, x14, x15);
+  StringHelper::GenerateCompareFlatAsciiStrings(masm, left, right, x12, x13,
+                                                x14, x15);
 
   __ Bind(&runtime);
 
   // Push arguments back on to the stack.
   //  sp[0] = right string
   //  sp[8] = left string.
   __ Push(left, right);
 
   // Call the runtime.
   // Returns -1 (less), 0 (equal), or 1 (greater) tagged as a small integer.
@@ skipping 1128 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64