Rename ascii to one-byte where applicable.

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 585 matching lines @@
   // In the strict case, the EmitStrictTwoHeapObjectCompare already took care
   // of internalized strings.
   if ((cond == eq) && !strict()) {
     // Returns an answer for two internalized strings or two detectable objects.
     // Otherwise branches to the string case or not both strings case.
     EmitCheckForInternalizedStringsOrObjects(masm, lhs, rhs, lhs_map, rhs_map,
                                              lhs_type, rhs_type,
                                              &flat_string_check, &slow);
   }
 
-  // Check for both being sequential ASCII strings, and inline if that is the
-  // case.
+  // Check for both being sequential one-byte strings,
+  // and inline if that is the case.
   __ Bind(&flat_string_check);
-  __ JumpIfBothInstanceTypesAreNotSequentialAscii(lhs_type, rhs_type, x14,
-                                                  x15, &slow);
+  __ JumpIfBothInstanceTypesAreNotSequentialOneByte(lhs_type, rhs_type, x14,
+                                                    x15, &slow);
 
   __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, x10,
                       x11);
   if (cond == eq) {
-    StringHelper::GenerateFlatAsciiStringEquals(masm, lhs, rhs, x10, x11, x12);
+    StringHelper::GenerateFlatOneByteStringEquals(masm, lhs, rhs, x10, x11,
+                                                  x12);
   } else {
-    StringHelper::GenerateCompareFlatAsciiStrings(masm, lhs, rhs, x10, x11, x12,
-                                                  x13);
+    StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, x10, x11,
+                                                    x12, x13);
   }
 
   // Never fall through to here.
   if (FLAG_debug_code) {
     __ Unreachable();
   }
 
   __ Bind(&slow);
 
   __ Push(lhs, rhs);
@@ skipping 1470 matching lines @@
   //  jssp[24]: JSRegExp object
   Label runtime;
 
   // Use of registers for this function.
 
   // Variable registers:
   //   x10-x13                                  used as scratch registers
   //   w0       string_type                     type of subject string
   //   x2       jsstring_length                 subject string length
   //   x3       jsregexp_object                 JSRegExp object
-  //   w4       string_encoding                 ASCII or UC16
+  //   w4       string_encoding                 Latin1 or UC16
   //   w5       sliced_string_offset            if the string is a SlicedString
   //                                            offset to the underlying string
   //   w6       string_representation           groups attributes of the string:
   //                                              - is a string
   //                                              - type of the string
   //                                              - is a short external string
   Register string_type = w0;
   Register jsstring_length = x2;
   Register jsregexp_object = x3;
   Register string_encoding = w4;
@@ skipping 177 matching lines @@
   // Argument 2 (x1): We need to load argument 2 (the previous index) into x1
   // before entering the exit frame.
   __ SmiUntag(x1, x10);
 
   // The third bit determines the string encoding in string_type.
   STATIC_ASSERT(kOneByteStringTag == 0x04);
   STATIC_ASSERT(kTwoByteStringTag == 0x00);
   STATIC_ASSERT(kStringEncodingMask == 0x04);
 
   // Find the code object based on the assumptions above.
-  // kDataAsciiCodeOffset and kDataUC16CodeOffset are adjacent, adds an offset
+  // kDataOneByteCodeOffset and kDataUC16CodeOffset are adjacent, adds an offset
   // of kPointerSize to reach the latter.
-  DCHECK_EQ(JSRegExp::kDataAsciiCodeOffset + kPointerSize,
+  DCHECK_EQ(JSRegExp::kDataOneByteCodeOffset + kPointerSize,
             JSRegExp::kDataUC16CodeOffset);
   __ Mov(x10, kPointerSize);
-  // We will need the encoding later: ASCII = 0x04
-  //                                  UC16  = 0x00
+  // We will need the encoding later: Latin1 = 0x04
+  //                                  UC16   = 0x00
   __ Ands(string_encoding, string_type, kStringEncodingMask);
   __ CzeroX(x10, ne);
   __ Add(x10, regexp_data, x10);
-  __ Ldr(code_object, FieldMemOperand(x10, JSRegExp::kDataAsciiCodeOffset));
+  __ Ldr(code_object, FieldMemOperand(x10, JSRegExp::kDataOneByteCodeOffset));
 
   // (E) Carry on.  String handling is done.
 
   // Check that the irregexp code has been generated for the actual string
   // encoding. If it has, the field contains a code object otherwise it contains
   // a smi (code flushing support).
   __ JumpIfSmi(code_object, &runtime);
 
   // All checks done. Now push arguments for native regexp code.
   __ IncrementCounter(isolate()->counters()->regexp_entry_native(), 1,
@@ skipping 22 matching lines @@
   // Load start of the subject string.
   __ Add(start, subject, SeqString::kHeaderSize - kHeapObjectTag);
   // Load the length from the original subject string from the previous stack
   // frame. Therefore we have to use fp, which points exactly to two pointer
   // sizes below the previous sp. (Because creating a new stack frame pushes
   // the previous fp onto the stack and decrements sp by 2 * kPointerSize.)
   __ Ldr(subject, MemOperand(fp, kSubjectOffset + 2 * kPointerSize));
   __ Ldr(length, UntagSmiFieldMemOperand(subject, String::kLengthOffset));
 
   // Handle UC16 encoding, two bytes make one character.
-  //   string_encoding: if ASCII: 0x04
-  //                    if UC16:  0x00
+  //   string_encoding: if Latin1: 0x04
+  //                    if UC16:   0x00
   STATIC_ASSERT(kStringEncodingMask == 0x04);
   __ Ubfx(string_encoding, string_encoding, 2, 1);
   __ Eor(string_encoding, string_encoding, 1);
-  //   string_encoding: if ASCII: 0
-  //                    if UC16:  1
+  //   string_encoding: if Latin1: 0
+  //                    if UC16:   1
 
   // Convert string positions from characters to bytes.
   // Previous index is in x1.
   __ Lsl(previous_index_in_bytes, w1, string_encoding);
   __ Lsl(length, length, string_encoding);
   __ Lsl(sliced_string_offset, sliced_string_offset, string_encoding);
 
   // Argument 1 (x0): Subject string.
   __ Mov(x0, subject);
 
@@ skipping 775 matching lines @@
   __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
   __ JumpIfNotSmi(code_, &slow_case_);
   __ Cmp(code_, Smi::FromInt(String::kMaxOneByteCharCode));
   __ B(hi, &slow_case_);
 
   __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
-  // At this point code register contains smi tagged ASCII char code.
+  // At this point code register contains smi tagged one-byte char code.
   __ Add(result_, result_, Operand::UntagSmiAndScale(code_, kPointerSizeLog2));
   __ Ldr(result_, FieldMemOperand(result_, FixedArray::kHeaderSize));
   __ JumpIfRoot(result_, Heap::kUndefinedValueRootIndex, &slow_case_);
   __ Bind(&exit_);
 }
 
 
 void StringCharFromCodeGenerator::GenerateSlow(
     MacroAssembler* masm,
     const RuntimeCallHelper& call_helper) {
@@ skipping 225 matching lines @@
     STATIC_ASSERT(kInternalizedTag == 0);
     Label not_internalized_strings;
     __ Orr(x12, lhs_type, rhs_type);
     __ TestAndBranchIfAnySet(
         x12, kIsNotInternalizedMask, &not_internalized_strings);
     // Result is in rhs (x0), and not EQUAL, as rhs is not a smi.
     __ Ret();
     __ Bind(&not_internalized_strings);
   }
 
-  // Check that both strings are sequential ASCII.
+  // Check that both strings are sequential one-byte.
   Label runtime;
-  __ JumpIfBothInstanceTypesAreNotSequentialAscii(
-      lhs_type, rhs_type, x12, x13, &runtime);
+  __ JumpIfBothInstanceTypesAreNotSequentialOneByte(lhs_type, rhs_type, x12,
+                                                    x13, &runtime);
 
-  // Compare flat ASCII strings. Returns when done.
+  // Compare flat one-byte strings. Returns when done.
   if (equality) {
-    StringHelper::GenerateFlatAsciiStringEquals(masm, lhs, rhs, x10, x11, x12);
+    StringHelper::GenerateFlatOneByteStringEquals(masm, lhs, rhs, x10, x11,
+                                                  x12);
   } else {
-    StringHelper::GenerateCompareFlatAsciiStrings(masm, lhs, rhs, x10, x11, x12,
-                                                  x13);
+    StringHelper::GenerateCompareFlatOneByteStrings(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 226 matching lines @@
     __ B(lt, &copy_routine);
     // Allocate new sliced string. At this point we do not reload the instance
     // type including the string encoding because we simply rely on the info
     // provided by the original string. It does not matter if the original
     // string's encoding is wrong because we always have to recheck encoding of
     // the newly created string's parent anyway due to externalized strings.
     Label two_byte_slice, set_slice_header;
     STATIC_ASSERT((kStringEncodingMask & kOneByteStringTag) != 0);
     STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0);
     __ Tbz(input_type, MaskToBit(kStringEncodingMask), &two_byte_slice);
-    __ AllocateAsciiSlicedString(result_string, result_length, x3, x4,
-                                 &runtime);
+    __ AllocateOneByteSlicedString(result_string, result_length, x3, x4,
+                                   &runtime);
     __ B(&set_slice_header);
 
     __ Bind(&two_byte_slice);
     __ AllocateTwoByteSlicedString(result_string, result_length, x3, x4,
                                    &runtime);
 
     __ Bind(&set_slice_header);
     __ SmiTag(from);
     __ Str(from, FieldMemOperand(result_string, SlicedString::kOffsetOffset));
     __ Str(unpacked_string,
@@ skipping 29 matching lines @@
   // unpacked_char0 points to the first character of the underlying string.
   __ B(&allocate_result);
 
   __ Bind(&sequential_string);
   // Locate first character of underlying subject string.
   STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
   __ Add(unpacked_char0, unpacked_string,
          SeqOneByteString::kHeaderSize - kHeapObjectTag);
 
   __ Bind(&allocate_result);
-  // Sequential ASCII string. Allocate the result.
+  // Sequential one-byte string. Allocate the result.
   STATIC_ASSERT((kOneByteStringTag & kStringEncodingMask) != 0);
   __ Tbz(input_type, MaskToBit(kStringEncodingMask), &two_byte_sequential);
 
-  // Allocate and copy the resulting ASCII string.
-  __ AllocateAsciiString(result_string, result_length, x3, x4, x5, &runtime);
+  // Allocate and copy the resulting one-byte string.
+  __ AllocateOneByteString(result_string, result_length, x3, x4, x5, &runtime);
 
   // Locate first character of substring to copy.
   __ Add(substring_char0, unpacked_char0, from);
 
   // Locate first character of result.
   __ Add(result_char0, result_string,
          SeqOneByteString::kHeaderSize - kHeapObjectTag);
 
   STATIC_ASSERT((SeqOneByteString::kHeaderSize & kObjectAlignmentMask) == 0);
   __ CopyBytes(result_char0, substring_char0, result_length, x3, kCopyLong);
@@ skipping 32 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 StringHelper::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
-                                                 Register left, Register right,
-                                                 Register scratch1,
-                                                 Register scratch2,
-                                                 Register scratch3) {
+void StringHelper::GenerateFlatOneByteStringEquals(
+    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));
   __ Cmp(left_length, right_length);
   __ B(eq, &check_zero_length);
 
   __ Bind(&strings_not_equal);
   __ Mov(result, Smi::FromInt(NOT_EQUAL));
   __ Ret();
 
   // Check if the length is zero. If so, the strings must be equal (and empty.)
   Label compare_chars;
   __ Bind(&check_zero_length);
   STATIC_ASSERT(kSmiTag == 0);
   __ Cbnz(left_length, &compare_chars);
   __ Mov(result, Smi::FromInt(EQUAL));
   __ Ret();
 
   // Compare characters. Falls through if all characters are equal.
   __ Bind(&compare_chars);
-  GenerateAsciiCharsCompareLoop(masm, left, right, left_length, scratch2,
-                                scratch3, &strings_not_equal);
+  GenerateOneByteCharsCompareLoop(masm, left, right, left_length, scratch2,
+                                  scratch3, &strings_not_equal);
 
   // Characters in strings are equal.
   __ Mov(result, Smi::FromInt(EQUAL));
   __ Ret();
 }
 
 
-void StringHelper::GenerateCompareFlatAsciiStrings(
+void StringHelper::GenerateCompareFlatOneByteStrings(
     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;
   __ Csel(min_length, scratch2, scratch1, gt);
   __ Cbz(min_length, &compare_lengths);
 
   // Compare loop.
-  GenerateAsciiCharsCompareLoop(masm,
-                                left, right, min_length, scratch2, scratch4,
-                                &result_not_equal);
+  GenerateOneByteCharsCompareLoop(masm, left, right, min_length, scratch2,
+                                  scratch4, &result_not_equal);
 
   // Compare lengths - strings up to min-length are equal.
   __ Bind(&compare_lengths);
 
   DCHECK(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
 
   // Use length_delta as result if it's zero.
   Register result = x0;
   __ Subs(result, length_delta, 0);
 
   __ Bind(&result_not_equal);
   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 StringHelper::GenerateAsciiCharsCompareLoop(
+void StringHelper::GenerateOneByteCharsCompareLoop(
     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);
@@ skipping 29 matching lines @@
 
   Label not_same;
   __ Subs(result, right, left);
   __ B(ne, &not_same);
   STATIC_ASSERT(EQUAL == 0);
   __ IncrementCounter(counters->string_compare_native(), 1, x3, x4);
   __ Ret();
 
   __ Bind(&not_same);
 
-  // Check that both objects are sequential ASCII strings.
-  __ JumpIfEitherIsNotSequentialAsciiStrings(left, right, x12, x13, &runtime);
+  // Check that both objects are sequential one-byte strings.
+  __ JumpIfEitherIsNotSequentialOneByteStrings(left, right, x12, x13, &runtime);
 
-  // Compare flat ASCII strings natively. Remove arguments from stack first,
+  // Compare flat one-byte strings natively. Remove arguments from stack first,
   // as this function will generate a return.
   __ IncrementCounter(counters->string_compare_native(), 1, x3, x4);
-  StringHelper::GenerateCompareFlatAsciiStrings(masm, left, right, x12, x13,
-                                                x14, x15);
+  StringHelper::GenerateCompareFlatOneByteStrings(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 1117 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64