[string] Refactor direct string conversions

src/builtins/builtins-regexp.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/builtins/builtins-regexp.h"
 
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 198 matching lines @@
       Branch(IntPtrGreaterThanOrEqual(var_i.value(), names_length), &out,
              &loop);
     }
   }
 
   Bind(&out);
   return result;
 }
 
 void RegExpBuiltinsAssembler::GetStringPointers(
-    Node* const string, Node* const offset, Node* const last_index,
-    Node* const string_length, bool is_one_byte, Variable* var_string_start,
-    Variable* var_string_end) {
+    Node* const string_data, Node* const offset, Node* const last_index,
+    Node* const string_length, String::Encoding encoding,
+    Variable* var_string_start, Variable* var_string_end) {
   DCHECK_EQ(var_string_start->rep(), MachineType::PointerRepresentation());
   DCHECK_EQ(var_string_end->rep(), MachineType::PointerRepresentation());
 
-  STATIC_ASSERT(SeqOneByteString::kHeaderSize == SeqTwoByteString::kHeaderSize);
-  const int kHeaderSize = SeqOneByteString::kHeaderSize - kHeapObjectTag;
-  const ElementsKind kind = is_one_byte ? UINT8_ELEMENTS : UINT16_ELEMENTS;
+  const ElementsKind kind = (encoding == String::ONE_BYTE_ENCODING)
+                                ? UINT8_ELEMENTS
+                                : UINT16_ELEMENTS;
 
   Node* const from_offset = ElementOffsetFromIndex(
-      IntPtrAdd(offset, last_index), kind, INTPTR_PARAMETERS, kHeaderSize);
-  var_string_start->Bind(IntPtrAdd(string, from_offset));
+      IntPtrAdd(offset, last_index), kind, INTPTR_PARAMETERS);
+  var_string_start->Bind(IntPtrAdd(string_data, from_offset));
 
   Node* const to_offset = ElementOffsetFromIndex(
-      IntPtrAdd(offset, string_length), kind, INTPTR_PARAMETERS, kHeaderSize);
-  var_string_end->Bind(IntPtrAdd(string, to_offset));
+      IntPtrAdd(offset, string_length), kind, INTPTR_PARAMETERS);
+  var_string_end->Bind(IntPtrAdd(string_data, to_offset));
 }
 
 Node* RegExpBuiltinsAssembler::IrregexpExec(Node* const context,
                                             Node* const regexp,
                                             Node* const string,
                                             Node* const last_index,
                                             Node* const match_info) {
 // Just jump directly to runtime if native RegExp is not selected at compile
 // time or if regexp entry in generated code is turned off runtime switch or
 // at compilation.
 #ifdef V8_INTERPRETED_REGEXP
   return CallRuntime(Runtime::kRegExpExec, context, regexp, string, last_index,
                      match_info);
 #else   // V8_INTERPRETED_REGEXP
   CSA_ASSERT(this, TaggedIsNotSmi(regexp));
   CSA_ASSERT(this, HasInstanceType(regexp, JS_REGEXP_TYPE));
 
   CSA_ASSERT(this, TaggedIsNotSmi(string));
   CSA_ASSERT(this, IsString(string));
 
   CSA_ASSERT(this, IsHeapNumberMap(LoadReceiverMap(last_index)));
   CSA_ASSERT(this, IsFixedArrayMap(LoadReceiverMap(match_info)));
 
   Node* const int_zero = IntPtrConstant(0);
 
+  ToDirectStringAssembler to_direct(state(), string);
+
   Variable var_result(this, MachineRepresentation::kTagged);
-  Variable var_string(this, MachineType::PointerRepresentation(), int_zero);
-  Variable var_string_offset(this, MachineType::PointerRepresentation(),
-                             int_zero);
-  Variable var_string_instance_type(this, MachineRepresentation::kWord32,
-                                    Int32Constant(0));
-
   Label out(this), runtime(this, Label::kDeferred);
 
   // External constants.
   Node* const regexp_stack_memory_size_address = ExternalConstant(
       ExternalReference::address_of_regexp_stack_memory_size(isolate()));
   Node* const static_offsets_vector_address = ExternalConstant(
       ExternalReference::address_of_static_offsets_vector(isolate()));
   Node* const pending_exception_address = ExternalConstant(
       ExternalReference(Isolate::kPendingExceptionAddress, isolate()));
 
@@ skipping 23 matching lines @@
 
     STATIC_ASSERT(Isolate::kJSRegexpStaticOffsetsVectorSize >= 2);
     GotoIf(SmiAbove(
                capture_count,
                SmiConstant(Isolate::kJSRegexpStaticOffsetsVectorSize / 2 - 1)),
            &runtime);
   }
 
   // Unpack the string if possible.
 
-  var_string.Bind(BitcastTaggedToWord(string));
-  var_string_offset.Bind(int_zero);
-  var_string_instance_type.Bind(LoadInstanceType(string));
-
-  {
-    TryUnpackString(&var_string, &var_string_offset, &var_string_instance_type,
-                    &runtime);
-
-    // At this point, {var_string} may contain a faked sequential string (i.e.
-    // an external string with an adjusted offset) so we cannot assert
-    // IsString({var_string}). We also cannot allocate after this point since
-    // GC could move {var_string}'s underlying string.
-  }
+  to_direct.TryToDirect(&runtime);
 
   Node* const smi_string_length = LoadStringLength(string);
 
   // Bail out to runtime for invalid {last_index} values.
   GotoIfNot(TaggedIsSmi(last_index), &runtime);
   GotoIf(SmiAboveOrEqual(last_index, smi_string_length), &runtime);
 
   // Load the irregexp code object and offsets into the subject string. Both
   // depend on whether the string is one- or two-byte.
 
   Node* const int_last_index = SmiUntag(last_index);
 
   Variable var_string_start(this, MachineType::PointerRepresentation());
   Variable var_string_end(this, MachineType::PointerRepresentation());
   Variable var_code(this, MachineRepresentation::kTagged);
 
   {
     Node* const int_string_length = SmiUntag(smi_string_length);
-
-    Node* const string_instance_type = var_string_instance_type.value();
-    CSA_ASSERT(this, IsSequentialStringInstanceType(string_instance_type));
+    Node* const direct_string_data = to_direct.PointerToData(&runtime);
 
     Label next(this), if_isonebyte(this), if_istwobyte(this, Label::kDeferred);
-    Branch(IsOneByteStringInstanceType(string_instance_type), &if_isonebyte,
-           &if_istwobyte);
+    Branch(IsOneByteStringInstanceType(to_direct.instance_type()),
+           &if_isonebyte, &if_istwobyte);
 
     Bind(&if_isonebyte);
     {
-      const bool kIsOneByte = true;
-      GetStringPointers(var_string.value(), var_string_offset.value(),
-                        int_last_index, int_string_length, kIsOneByte,
+      GetStringPointers(direct_string_data, to_direct.offset(), int_last_index,
+                        int_string_length, String::ONE_BYTE_ENCODING,
                         &var_string_start, &var_string_end);
       var_code.Bind(
           LoadFixedArrayElement(data, JSRegExp::kIrregexpLatin1CodeIndex));
       Goto(&next);
     }
 
     Bind(&if_istwobyte);
     {
-      const bool kIsOneByte = false;
-      GetStringPointers(var_string.value(), var_string_offset.value(),
-                        int_last_index, int_string_length, kIsOneByte,
+      GetStringPointers(direct_string_data, to_direct.offset(), int_last_index,
+                        int_string_length, String::TWO_BYTE_ENCODING,
                         &var_string_start, &var_string_end);
       var_code.Bind(
           LoadFixedArrayElement(data, JSRegExp::kIrregexpUC16CodeIndex));
       Goto(&next);
     }
 
     Bind(&next);
   }
 
   // Check that the irregexp code has been generated for the actual string
@@ skipping 2465 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8