Rename SeqAsciiString

src/x64/full-codegen-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3540 matching lines @@
                                times_pointer_size,
                                FixedArray::kHeaderSize));
   __ JumpIfSmi(string, &bailout);
   __ movq(scratch, FieldOperand(string, HeapObject::kMapOffset));
   __ movzxbl(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
   __ andb(scratch, Immediate(
       kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask));
   __ cmpb(scratch, Immediate(kStringTag | kOneByteStringTag | kSeqStringTag));
   __ j(not_equal, &bailout);
   __ AddSmiField(string_length,
-                 FieldOperand(string, SeqAsciiString::kLengthOffset));
+                 FieldOperand(string, SeqOneByteString::kLengthOffset));
   __ j(overflow, &bailout);
   __ incl(index);
   __ cmpl(index, array_length);
   __ j(less, &loop);
 
   // Live registers:
   // string_length: Sum of string lengths.
   // elements: FixedArray of strings.
   // index: Array length.
   // array_length: Array length.
@@ skipping 26 matching lines @@
   __ j(not_equal, &bailout);
 
   // Live registers:
   // string_length: Sum of string lengths.
   // elements: FixedArray of strings.
   // index: Array length.
   // string: Separator string.
 
   // Add (separator length times (array_length - 1)) to string_length.
   __ SmiToInteger32(scratch,
-                    FieldOperand(string, SeqAsciiString::kLengthOffset));
+                    FieldOperand(string, SeqOneByteString::kLengthOffset));
   __ decl(index);
   __ imull(scratch, index);
   __ j(overflow, &bailout);
   __ addl(string_length, scratch);
   __ j(overflow, &bailout);
 
   // Live registers and stack values:
   //   string_length: Total length of result string.
   //   elements: FixedArray of strings.
   __ AllocateAsciiString(result_pos, string_length, scratch,
                          index, string, &bailout);
   __ movq(result_operand, result_pos);
-  __ lea(result_pos, FieldOperand(result_pos, SeqAsciiString::kHeaderSize));
+  __ lea(result_pos, FieldOperand(result_pos, SeqOneByteString::kHeaderSize));
 
   __ movq(string, separator_operand);
-  __ SmiCompare(FieldOperand(string, SeqAsciiString::kLengthOffset),
+  __ SmiCompare(FieldOperand(string, SeqOneByteString::kLengthOffset),
                 Smi::FromInt(1));
   __ j(equal, &one_char_separator);
   __ j(greater, &long_separator);
 
 
   // Empty separator case:
   __ Set(index, 0);
   __ movl(scratch, array_length_operand);
   __ jmp(&loop_1_condition);
   // Loop condition: while (index < array_length).
   __ bind(&loop_1);
   // Each iteration of the loop concatenates one string to the result.
   // Live values in registers:
   //   index: which element of the elements array we are adding to the result.
   //   result_pos: the position to which we are currently copying characters.
   //   elements: the FixedArray of strings we are joining.
   //   scratch: array length.
 
   // Get string = array[index].
   __ movq(string, FieldOperand(elements, index,
                                times_pointer_size,
                                FixedArray::kHeaderSize));
   __ SmiToInteger32(string_length,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
-         FieldOperand(string, SeqAsciiString::kHeaderSize));
+         FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ CopyBytes(result_pos, string, string_length);
   __ incl(index);
   __ bind(&loop_1_condition);
   __ cmpl(index, scratch);
   __ j(less, &loop_1);  // Loop while (index < array_length).
   __ jmp(&done);
 
   // Generic bailout code used from several places.
   __ bind(&bailout);
   __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
   __ jmp(&return_result);
 
 
   // One-character separator case
   __ bind(&one_char_separator);
   // Get the separator ASCII character value.
   // Register "string" holds the separator.
-  __ movzxbl(scratch, FieldOperand(string, SeqAsciiString::kHeaderSize));
+  __ movzxbl(scratch, FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ Set(index, 0);
   // Jump into the loop after the code that copies the separator, so the first
   // element is not preceded by a separator
   __ jmp(&loop_2_entry);
   // Loop condition: while (index < length).
   __ bind(&loop_2);
   // Each iteration of the loop concatenates one string to the result.
   // Live values in registers:
   //   elements: The FixedArray of strings we are joining.
   //   index: which element of the elements array we are adding to the result.
   //   result_pos: the position to which we are currently copying characters.
   //   scratch: Separator character.
 
   // Copy the separator character to the result.
   __ movb(Operand(result_pos, 0), scratch);
   __ incq(result_pos);
 
   __ bind(&loop_2_entry);
   // Get string = array[index].
   __ movq(string, FieldOperand(elements, index,
                                times_pointer_size,
                                FixedArray::kHeaderSize));
   __ SmiToInteger32(string_length,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
-         FieldOperand(string, SeqAsciiString::kHeaderSize));
+         FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ CopyBytes(result_pos, string, string_length);
   __ incl(index);
   __ cmpl(index, array_length_operand);
   __ j(less, &loop_2);  // End while (index < length).
   __ jmp(&done);
 
 
   // Long separator case (separator is more than one character).
   __ bind(&long_separator);
 
   // Make elements point to end of elements array, and index
   // count from -array_length to zero, so we don't need to maintain
   // a loop limit.
   __ movl(index, array_length_operand);
   __ lea(elements, FieldOperand(elements, index, times_pointer_size,
                                 FixedArray::kHeaderSize));
   __ neg(index);
 
   // Replace separator string with pointer to its first character, and
   // make scratch be its length.
   __ movq(string, separator_operand);
   __ SmiToInteger32(scratch,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
-         FieldOperand(string, SeqAsciiString::kHeaderSize));
+         FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ movq(separator_operand, string);
 
   // Jump into the loop after the code that copies the separator, so the first
   // element is not preceded by a separator
   __ jmp(&loop_3_entry);
   // Loop condition: while (index < length).
   __ bind(&loop_3);
   // Each iteration of the loop concatenates one string to the result.
   // Live values in registers:
   //   index: which element of the elements array we are adding to the result.
   //   result_pos: the position to which we are currently copying characters.
   //   scratch: Separator length.
   //   separator_operand (rsp[0x10]): Address of first char of separator.
 
   // Copy the separator to the result.
   __ movq(string, separator_operand);
   __ movl(string_length, scratch);
   __ CopyBytes(result_pos, string, string_length, 2);
 
   __ bind(&loop_3_entry);
   // Get string = array[index].
   __ movq(string, Operand(elements, index, times_pointer_size, 0));
   __ SmiToInteger32(string_length,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
-         FieldOperand(string, SeqAsciiString::kHeaderSize));
+         FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ CopyBytes(result_pos, string, string_length);
   __ incq(index);
   __ j(not_equal, &loop_3);  // Loop while (index < 0).
 
   __ bind(&done);
   __ movq(rax, result_operand);
 
   __ bind(&return_result);
   // Drop temp values from the stack, and restore context register.
   __ addq(rsp, Immediate(3 * kPointerSize));
@@ skipping 736 matching lines @@
   *context_length = 0;
   return previous_;
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64