Rename ascii to one-byte where applicable.

src/arm64/full-codegen-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/code-stubs.h"
 #include "src/codegen.h"
@@ skipping 3488 matching lines @@
 
   __ AssertString(x0);
 
   __ Ldr(x10, FieldMemOperand(x0, String::kHashFieldOffset));
   __ IndexFromHash(x10, x0);
 
   context()->Plug(x0);
 }
 
 
-void FullCodeGenerator::EmitFastAsciiArrayJoin(CallRuntime* expr) {
-  ASM_LOCATION("FullCodeGenerator::EmitFastAsciiArrayJoin");
+void FullCodeGenerator::EmitFastOneByteArrayJoin(CallRuntime* expr) {
+  ASM_LOCATION("FullCodeGenerator::EmitFastOneByteArrayJoin");
 
   ZoneList<Expression*>* args = expr->arguments();
   DCHECK(args->length() == 2);
   VisitForStackValue(args->at(1));
   VisitForAccumulatorValue(args->at(0));
 
   Register array = x0;
   Register result = x0;
   Register elements = x1;
   Register element = x2;
@@ skipping 31 matching lines @@
   __ Ldrsw(array_length,
            UntagSmiFieldMemOperand(array, JSArray::kLengthOffset));
   __ Cbnz(array_length, &non_trivial_array);
   __ LoadRoot(result, Heap::kempty_stringRootIndex);
   __ B(&done);
 
   __ Bind(&non_trivial_array);
   // Get the FixedArray containing array's elements.
   __ Ldr(elements, FieldMemOperand(array, JSArray::kElementsOffset));
 
-  // Check that all array elements are sequential ASCII strings, and
+  // Check that all array elements are sequential one-byte strings, and
   // accumulate the sum of their lengths.
   __ Mov(string_length, 0);
   __ Add(element, elements, FixedArray::kHeaderSize - kHeapObjectTag);
   __ Add(elements_end, element, Operand(array_length, LSL, kPointerSizeLog2));
   // Loop condition: while (element < elements_end).
   // Live values in registers:
   //   elements: Fixed array of strings.
   //   array_length: Length of the fixed array of strings (not smi)
   //   separator: Separator string
   //   string_length: Accumulated sum of string lengths (not smi).
   //   element: Current array element.
   //   elements_end: Array end.
   if (FLAG_debug_code) {
     __ Cmp(array_length, 0);
-    __ Assert(gt, kNoEmptyArraysHereInEmitFastAsciiArrayJoin);
+    __ Assert(gt, kNoEmptyArraysHereInEmitFastOneByteArrayJoin);
   }
   __ Bind(&loop);
   __ Ldr(string, MemOperand(element, kPointerSize, PostIndex));
   __ JumpIfSmi(string, &bailout);
   __ Ldr(scratch1, FieldMemOperand(string, HeapObject::kMapOffset));
   __ Ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
-  __ JumpIfInstanceTypeIsNotSequentialAscii(scratch1, scratch2, &bailout);
+  __ JumpIfInstanceTypeIsNotSequentialOneByte(scratch1, scratch2, &bailout);
   __ Ldrsw(scratch1,
            UntagSmiFieldMemOperand(string, SeqOneByteString::kLengthOffset));
   __ Adds(string_length, string_length, scratch1);
   __ B(vs, &bailout);
   __ Cmp(element, elements_end);
   __ B(lt, &loop);
 
   // If array_length is 1, return elements[0], a string.
   __ Cmp(array_length, 1);
   __ B(ne, &not_size_one_array);
   __ Ldr(result, FieldMemOperand(elements, FixedArray::kHeaderSize));
   __ B(&done);
 
   __ Bind(&not_size_one_array);
 
   // Live values in registers:
   //   separator: Separator string
   //   array_length: Length of the array (not smi).
   //   string_length: Sum of string lengths (not smi).
   //   elements: FixedArray of strings.
 
-  // Check that the separator is a flat ASCII string.
+  // Check that the separator is a flat one-byte string.
   __ JumpIfSmi(separator, &bailout);
   __ Ldr(scratch1, FieldMemOperand(separator, HeapObject::kMapOffset));
   __ Ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
-  __ JumpIfInstanceTypeIsNotSequentialAscii(scratch1, scratch2, &bailout);
+  __ JumpIfInstanceTypeIsNotSequentialOneByte(scratch1, scratch2, &bailout);
 
   // Add (separator length times array_length) - separator length to the
   // string_length to get the length of the result string.
   // Load the separator length as untagged.
   // We assume little endianness, and that the length is positive.
   __ Ldrsw(separator_length,
            UntagSmiFieldMemOperand(separator,
                                    SeqOneByteString::kLengthOffset));
   __ Sub(string_length, string_length, separator_length);
   __ Umaddl(string_length, array_length.W(), separator_length.W(),
             string_length);
 
   // Get first element in the array.
   __ Add(element, elements, FixedArray::kHeaderSize - kHeapObjectTag);
   // Live values in registers:
   //   element: First array element
   //   separator: Separator string
   //   string_length: Length of result string (not smi)
   //   array_length: Length of the array (not smi).
-  __ AllocateAsciiString(result, string_length, scratch1, scratch2, scratch3,
-                         &bailout);
+  __ AllocateOneByteString(result, string_length, scratch1, scratch2, scratch3,
+                           &bailout);
 
   // Prepare for looping. Set up elements_end to end of the array. Set
   // result_pos to the position of the result where to write the first
   // character.
-  // TODO(all): useless unless AllocateAsciiString trashes the register.
+  // TODO(all): useless unless AllocateOneByteString trashes the register.
   __ Add(elements_end, element, Operand(array_length, LSL, kPointerSizeLog2));
   __ Add(result_pos, result, SeqOneByteString::kHeaderSize - kHeapObjectTag);
 
   // Check the length of the separator.
   __ Cmp(separator_length, 1);
   __ B(eq, &one_char_separator);
   __ B(gt, &long_separator);
 
   // Empty separator case
   __ Bind(&empty_separator_loop);
   // Live values in registers:
   //   result_pos: the position to which we are currently copying characters.
   //   element: Current array element.
   //   elements_end: Array end.
 
   // Copy next array element to the result.
   __ Ldr(string, MemOperand(element, kPointerSize, PostIndex));
   __ Ldrsw(string_length,
            UntagSmiFieldMemOperand(string, String::kLengthOffset));
   __ Add(string, string, SeqOneByteString::kHeaderSize - kHeapObjectTag);
   __ CopyBytes(result_pos, string, string_length, scratch1);
   __ Cmp(element, elements_end);
   __ B(lt, &empty_separator_loop);  // End while (element < elements_end).
   __ B(&done);
 
   // One-character separator case
   __ Bind(&one_char_separator);
-  // Replace separator with its ASCII character value.
+  // Replace separator with its one-byte character value.
   __ Ldrb(separator, FieldMemOperand(separator, SeqOneByteString::kHeaderSize));
   // Jump into the loop after the code that copies the separator, so the first
   // element is not preceded by a separator
   __ B(&one_char_separator_loop_entry);
 
   __ Bind(&one_char_separator_loop);
   // Live values in registers:
   //   result_pos: the position to which we are currently copying characters.
   //   element: Current array element.
   //   elements_end: Array end.
-  //   separator: Single separator ASCII char (in lower byte).
+  //   separator: Single separator one-byte char (in lower byte).
 
   // Copy the separator character to the result.
   __ Strb(separator, MemOperand(result_pos, 1, PostIndex));
 
   // Copy next array element to the result.
   __ Bind(&one_char_separator_loop_entry);
   __ Ldr(string, MemOperand(element, kPointerSize, PostIndex));
   __ Ldrsw(string_length,
            UntagSmiFieldMemOperand(string, String::kLengthOffset));
   __ Add(string, string, SeqOneByteString::kHeaderSize - kHeapObjectTag);
@@ skipping 1225 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64