[stubs]: Support 1->2 byte copies in CopyStringCharacters

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
 
@@ skipping 2055 matching lines @@
     Bind(&next_iter);
     Node* compare = WordNotEqual(from_offset, limit_offset);
     Branch(compare, &decrement, &done);
   }
 
   Bind(&done);
   IncrementCounter(isolate()->counters()->inlined_copied_elements(), 1);
   Comment("] CopyFixedArrayElements");
 }
 
-void CodeStubAssembler::CopyStringCharacters(compiler::Node* from_string,
-                                             compiler::Node* to_string,
-                                             compiler::Node* from_index,
-                                             compiler::Node* to_index,
-                                             compiler::Node* character_count,
-                                             String::Encoding encoding,
-                                             ParameterMode mode) {
-  bool one_byte = encoding == String::ONE_BYTE_ENCODING;
-  Comment(one_byte ? "CopyStringCharacters ONE_BYTE_ENCODING"
-                   : "CopyStringCharacters TWO_BYTE_ENCODING");
+void CodeStubAssembler::CopyStringCharacters(
+    compiler::Node* from_string, compiler::Node* to_string,
+    compiler::Node* from_index, compiler::Node* to_index,
+    compiler::Node* character_count, String::Encoding from_encoding,
+    String::Encoding to_encoding, ParameterMode mode) {
+  bool from_one_byte = from_encoding == String::ONE_BYTE_ENCODING;
+  bool to_one_byte = to_encoding == String::ONE_BYTE_ENCODING;
+  DCHECK_IMPLIES(to_one_byte, from_one_byte);
+  Comment("CopyStringCharacters %s -> %s",
+          from_one_byte ? "ONE_BYTE_ENCODING" : "TWO_BYTE_ENCODING",
+          to_one_byte ? "ONE_BYTE_ENCODING" : "TWO_BYTE_ENCODING");
 
-  ElementsKind kind = one_byte ? UINT8_ELEMENTS : UINT16_ELEMENTS;
-  int header_size = (one_byte ? SeqOneByteString::kHeaderSize
-                              : SeqTwoByteString::kHeaderSize) -
-                    kHeapObjectTag;
-  Node* from_offset = ElementOffsetFromIndex(from_index, kind, mode);
-  Node* to_offset = ElementOffsetFromIndex(to_index, kind, mode);
-  Node* byte_count = ElementOffsetFromIndex(character_count, kind, mode);
+  ElementsKind from_kind = from_one_byte ? UINT8_ELEMENTS : UINT16_ELEMENTS;
+  ElementsKind to_kind = to_one_byte ? UINT8_ELEMENTS : UINT16_ELEMENTS;
+  STATIC_ASSERT(SeqOneByteString::kHeaderSize == SeqTwoByteString::kHeaderSize);
+  int header_size = SeqOneByteString::kHeaderSize - kHeapObjectTag;
+  Node* from_offset =
+      ElementOffsetFromIndex(from_index, from_kind, mode, header_size);
+  Node* to_offset =
+      ElementOffsetFromIndex(to_index, to_kind, mode, header_size);
+  Node* byte_count = ElementOffsetFromIndex(character_count, from_kind, mode);
   Node* limit_offset = IntPtrAddFoldConstants(from_offset, byte_count);
 
   // Prepare the fast loop
-  MachineType type = one_byte ? MachineType::Uint8() : MachineType::Uint16();
-  MachineRepresentation rep =
-      one_byte ? MachineRepresentation::kWord8 : MachineRepresentation::kWord16;
-  int increment = -(1 << ElementsKindToShiftSize(kind));
+  MachineType type =
+      from_one_byte ? MachineType::Uint8() : MachineType::Uint16();
+  MachineRepresentation rep = to_one_byte ? MachineRepresentation::kWord8
+                                          : MachineRepresentation::kWord16;
+  int from_increment = 1 << ElementsKindToShiftSize(from_kind);
+  int to_increment = 1 << ElementsKindToShiftSize(to_kind);
 
-  Node* to_string_adjusted = IntPtrAddFoldConstants(
-      to_string, IntPtrSubFoldConstants(to_offset, from_offset));
-  limit_offset =
-      IntPtrAddFoldConstants(limit_offset, IntPtrConstant(header_size));
-  from_offset =
-      IntPtrAddFoldConstants(from_offset, IntPtrConstant(header_size));
-
-  BuildFastLoop(MachineType::PointerRepresentation(), limit_offset, from_offset,
-                [from_string, to_string_adjusted, type, rep](
-                    CodeStubAssembler* assembler, Node* offset) {
+  Variable current_to_offset(this, MachineType::PointerRepresentation());
+  VariableList vars({&current_to_offset}, zone());
+  current_to_offset.Bind(to_offset);
+  int to_index_constant = 0, from_index_constant = 0;
+  Smi* to_index_smi = nullptr;
+  Smi* from_index_smi = nullptr;
+  bool index_same = (from_encoding == to_encoding) &&
+                    (from_index == to_index ||
+                     (ToInt32Constant(from_index, from_index_constant) &&
+                      ToInt32Constant(to_index, to_index_constant) &&
+                      from_index_constant == to_index_constant) ||
+                     (ToSmiConstant(from_index, from_index_smi) &&
+                      ToSmiConstant(to_index, to_index_smi) &&
+                      to_index_smi == from_index_smi));
+  BuildFastLoop(vars, MachineType::PointerRepresentation(), from_offset,
+                limit_offset,
+                [from_string, to_string, &current_to_offset, to_increment, type,
+                 rep, index_same](CodeStubAssembler* assembler, Node* offset) {
                   Node* value = assembler->Load(type, from_string, offset);
-                  assembler->StoreNoWriteBarrier(rep, to_string_adjusted,
-                                                 offset, value);
+                  assembler->StoreNoWriteBarrier(
+                      rep, to_string,
+                      index_same ? offset : current_to_offset.value(), value);
+                  if (!index_same) {
+                    current_to_offset.Bind(assembler->IntPtrAdd(
+                        current_to_offset.value(),
+                        assembler->IntPtrConstant(to_increment)));
+                  }
                 },
-                increment);
+                from_increment, IndexAdvanceMode::kPost);
 }
 
 Node* CodeStubAssembler::LoadElementAndPrepareForStore(Node* array,
                                                        Node* offset,
                                                        ElementsKind from_kind,
                                                        ElementsKind to_kind,
                                                        Label* if_hole) {
   if (IsFastDoubleElementsKind(from_kind)) {
     Node* value =
         LoadDoubleWithHoleCheck(array, offset, if_hole, MachineType::Float64());
@@ skipping 849 matching lines @@
                                         a->Int32Constant(kStringEncodingMask)),
                            a->Int32Constant(0)),
             &two_byte_sequential);
 
   // The subject string is a sequential one-byte string.
   {
     Node* result =
         a->AllocateSeqOneByteString(context, a->SmiToWord(character_count));
     a->CopyStringCharacters(from, result, from_index, smi_zero, character_count,
                             String::ONE_BYTE_ENCODING,
+                            String::ONE_BYTE_ENCODING,
                             CodeStubAssembler::SMI_PARAMETERS);
     var_result.Bind(result);
 
     a->Goto(&end);
   }
 
   // The subject string is a sequential two-byte string.
   a->Bind(&two_byte_sequential);
   {
     Node* result =
         a->AllocateSeqTwoByteString(context, a->SmiToWord(character_count));
     a->CopyStringCharacters(from, result, from_index, smi_zero, character_count,
                             String::TWO_BYTE_ENCODING,
+                            String::TWO_BYTE_ENCODING,
                             CodeStubAssembler::SMI_PARAMETERS);
     var_result.Bind(result);
 
     a->Goto(&end);
   }
 
   a->Bind(&end);
   return var_result.value();
 }
 
@@ skipping 281 matching lines @@
   Label two_byte(this);
   GotoIf(WordEqual(
              WordAnd(ored_instance_types, IntPtrConstant(kStringEncodingMask)),
              IntPtrConstant(kTwoByteStringTag)),
          &two_byte);
   // One-byte sequential string case
   Node* new_string =
       AllocateSeqOneByteString(context, new_length, SMI_PARAMETERS);
   CopyStringCharacters(left, new_string, SmiConstant(Smi::kZero),
                        SmiConstant(Smi::kZero), left_length,
+                       String::ONE_BYTE_ENCODING, String::ONE_BYTE_ENCODING,
+                       SMI_PARAMETERS);
+  CopyStringCharacters(right, new_string, SmiConstant(Smi::kZero), left_length,
+                       right_length, String::ONE_BYTE_ENCODING,
                        String::ONE_BYTE_ENCODING, SMI_PARAMETERS);
-  CopyStringCharacters(right, new_string, SmiConstant(Smi::kZero), left_length,
-                       right_length, String::ONE_BYTE_ENCODING, SMI_PARAMETERS);
   result.Bind(new_string);
   Goto(&done_native);
 
   Bind(&two_byte);
   {
     // Two-byte sequential string case
     new_string = AllocateSeqTwoByteString(context, new_length, SMI_PARAMETERS);
     CopyStringCharacters(left, new_string, SmiConstant(Smi::kZero),
                          SmiConstant(Smi::kZero), left_length,
-                         String::TWO_BYTE_ENCODING, SMI_PARAMETERS);
+                         String::TWO_BYTE_ENCODING, String::TWO_BYTE_ENCODING,
+                         SMI_PARAMETERS);
     CopyStringCharacters(right, new_string, SmiConstant(Smi::kZero),
                          left_length, right_length, String::TWO_BYTE_ENCODING,
-                         SMI_PARAMETERS);
+                         String::TWO_BYTE_ENCODING, SMI_PARAMETERS);
     result.Bind(new_string);
     Goto(&done_native);
   }
 
   Bind(&runtime);
   {
     result.Bind(CallRuntime(Runtime::kStringAdd, context, left, right));
     Goto(&done);
   }
 
@@ skipping 3631 matching lines @@
   StoreObjectFieldRoot(cell, WeakCell::kNextOffset,
                        Heap::kTheHoleValueRootIndex);
 
   // Store the WeakCell in the feedback vector.
   StoreFixedArrayElement(feedback_vector, slot, cell, UPDATE_WRITE_BARRIER,
                          CodeStubAssembler::SMI_PARAMETERS);
   return cell;
 }
 
 void CodeStubAssembler::BuildFastLoop(
+    const CodeStubAssembler::VariableList& vars,
     MachineRepresentation index_rep, Node* start_index, Node* end_index,
     std::function<void(CodeStubAssembler* assembler, Node* index)> body,
     int increment, IndexAdvanceMode mode) {
   Variable var(this, index_rep);
+  VariableList vars_copy(vars, zone());
+  vars_copy.Add(&var, zone());
   var.Bind(start_index);
-  Label loop(this, &var);
+  Label loop(this, vars_copy);
   Label after_loop(this);
   // Introduce an explicit second check of the termination condition before the
   // loop that helps turbofan generate better code. If there's only a single
   // check, then the CodeStubAssembler forces it to be at the beginning of the
   // loop requiring a backwards branch at the end of the loop (it's not possible
   // to force the loop header check at the end of the loop and branch forward to
   // it from the pre-header). The extra branch is slower in the case that the
   // loop actually iterates.
   Branch(WordEqual(var.value(), end_index), &after_loop, &loop);
   Bind(&loop);
@@ skipping 1741 matching lines @@
   Node* buffer_bit_field = LoadObjectField(
       buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8