[regexp] Port RegExpExecStub to CSA (mostly)

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"
 
 namespace v8 {
 namespace internal {
@@ skipping 2872 matching lines @@
   STATIC_ASSERT(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE);
   return Int32LessThanOrEqual(instance_type,
                               Int32Constant(LAST_SPECIAL_RECEIVER_TYPE));
 }
 
 Node* CodeStubAssembler::IsStringInstanceType(Node* instance_type) {
   STATIC_ASSERT(INTERNALIZED_STRING_TYPE == FIRST_TYPE);
   return Int32LessThan(instance_type, Int32Constant(FIRST_NONSTRING_TYPE));
 }
 
+Node* CodeStubAssembler::IsOneByteStringInstanceType(Node* instance_type) {
+  CSA_ASSERT(this, IsStringInstanceType(instance_type));
+  return Word32Equal(
+      Word32And(instance_type, Int32Constant(kStringEncodingMask)),
+      Int32Constant(kOneByteStringTag));
+}
+
+Node* CodeStubAssembler::IsSequentialStringInstanceType(Node* instance_type) {
+  CSA_ASSERT(this, IsStringInstanceType(instance_type));
+  return Word32Equal(
+      Word32And(instance_type, Int32Constant(kStringRepresentationMask)),
+      Int32Constant(kSeqStringTag));
+}
+
 Node* CodeStubAssembler::IsJSReceiverInstanceType(Node* instance_type) {
   STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
   return Int32GreaterThanOrEqual(instance_type,
                                  Int32Constant(FIRST_JS_RECEIVER_TYPE));
 }
 
 Node* CodeStubAssembler::IsJSReceiver(Node* object) {
   STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE);
   return IsJSReceiverInstanceType(LoadInstanceType(object));
 }
@@ skipping 345 matching lines @@
 // given character range using CopyStringCharacters.
 // |from_string| must be a sequential string. |from_index| and
 // |character_count| must be Smis s.t.
 // 0 <= |from_index| <= |from_index| + |character_count| < from_string.length.
 Node* AllocAndCopyStringCharacters(CodeStubAssembler* a, Node* context,
                                    Node* from, Node* from_instance_type,
                                    Node* from_index, Node* character_count) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
-  Label end(a), two_byte_sequential(a);
+  Label end(a), one_byte_sequential(a), two_byte_sequential(a);
   Variable var_result(a, MachineRepresentation::kTagged);
 
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
-  STATIC_ASSERT((kOneByteStringTag & kStringEncodingMask) != 0);
-  a->GotoIf(a->Word32Equal(a->Word32And(from_instance_type,
-                                        a->Int32Constant(kStringEncodingMask)),
-                           a->Int32Constant(0)),
-            &two_byte_sequential);
+  a->Branch(a->IsOneByteStringInstanceType(from_instance_type),
+            &one_byte_sequential, &two_byte_sequential);
 
   // The subject string is a sequential one-byte string.
+  a->Bind(&one_byte_sequential);
   {
     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);
@@ skipping 264 matching lines @@
                                         Node* const instance_type) {
   CSA_ASSERT(a, a->IsStringInstanceType(instance_type));
   STATIC_ASSERT(kShortExternalStringTag != 0);
   return a->Word32NotEqual(
       a->Word32And(instance_type, a->Int32Constant(kShortExternalStringMask)),
       a->Int32Constant(0));
 }
 
 }  // namespace
 
+void CodeStubAssembler::TryUnpackString(Variable* var_string,
+                                        Variable* var_offset,
+                                        Variable* var_instance_type,
+                                        Label* if_bailout) {
+  DCHECK_EQ(var_string->rep(), MachineType::PointerRepresentation());
+  DCHECK_EQ(var_offset->rep(), MachineType::PointerRepresentation());
+  DCHECK_EQ(var_instance_type->rep(), MachineRepresentation::kWord32);
+  CSA_ASSERT(this, IsString(var_string->value()));
+
+  Label out(this);
+
+  VariableList vars({var_string, var_offset, var_instance_type}, zone());
+  Label dispatch(this, vars);
+  Label if_isdirect(this);
+  Label if_iscons(this, Label::kDeferred);
+  Label if_isexternal(this, Label::kDeferred);
+  Label if_issliced(this, Label::kDeferred);
+  Label if_isthin(this, Label::kDeferred);
+
+  Goto(&dispatch);
+
+  // Dispatch based on string representation.
+  Bind(&dispatch);
+  {
+    int32_t values[] = {
+        kSeqStringTag,    kConsStringTag, kExternalStringTag,
+        kSlicedStringTag, kThinStringTag,
+    };
+    Label* labels[] = {
+        &if_isdirect, &if_iscons, &if_isexternal, &if_issliced, &if_isthin,
+    };
+    STATIC_ASSERT(arraysize(values) == arraysize(labels));
+
+    Node* const representation = Word32And(
+        var_instance_type->value(), Int32Constant(kStringRepresentationMask));
+    Switch(representation, if_bailout, values, labels, arraysize(values));
+  }
+
+  // Cons string.  Check whether it is flat, then fetch first part.
+  // Flat cons strings have an empty second part.
+  Bind(&if_iscons);
+  {
+    Node* const string = var_string->value();
+    GotoIfNot(IsEmptyString(LoadObjectField(string, ConsString::kSecondOffset)),
+              if_bailout);
+
+    Node* const lhs = LoadObjectField(string, ConsString::kFirstOffset);
+    var_string->Bind(BitcastTaggedToWord(lhs));
+    var_instance_type->Bind(LoadInstanceType(lhs));
+
+    Goto(&dispatch);
+  }
+
+  // Sliced string. Fetch parent and correct start index by offset.
+  Bind(&if_issliced);
+  {
+    Node* const string = var_string->value();
+    Node* const sliced_offset =
+        LoadObjectField(string, SlicedString::kOffsetOffset);
+    var_offset->Bind(IntPtrAdd(var_offset->value(), SmiUntag(sliced_offset)));
+
+    Node* const parent = LoadObjectField(string, SlicedString::kParentOffset);
+    var_string->Bind(BitcastTaggedToWord(parent));
+    var_instance_type->Bind(LoadInstanceType(parent));
+
+    Goto(&dispatch);
+  }
+
+  // Thin string. Fetch the actual string.
+  Bind(&if_isthin);
+  {
+    Node* const string = var_string->value();
+    Node* const actual_string =
+        LoadObjectField(string, ThinString::kActualOffset);
+    Node* const actual_instance_type = LoadInstanceType(actual_string);
+
+    var_string->Bind(BitcastTaggedToWord(actual_string));
+    var_instance_type->Bind(actual_instance_type);
+
+    Goto(&dispatch);
+  }
+
+  // External string.
+  Bind(&if_isexternal);
+  {
+    Node* const string = var_string->value();
+    Node* const faked_seq_string =
+        TryDerefExternalString(string, var_instance_type->value(), if_bailout);
+
+    STATIC_ASSERT(kSeqStringTag == 0x0);
+    Node* const faked_seq_instance_type = Word32Xor(
+        var_instance_type->value(), Int32Constant(kExternalStringTag));
+    CSA_ASSERT(this, IsSequentialStringInstanceType(faked_seq_instance_type));
+
+    var_string->Bind(faked_seq_string);
+    var_instance_type->Bind(faked_seq_instance_type);
+
+    Goto(&if_isdirect);
+  }
+
+  Bind(&if_isdirect);
+}
+
 Node* CodeStubAssembler::TryDerefExternalString(Node* const string,
                                                 Node* const instance_type,
                                                 Label* if_bailout) {
   Label out(this);
 
   USE(IsExternalStringInstanceType);
   CSA_ASSERT(this, IsExternalStringInstanceType(this, instance_type));
   GotoIf(IsShortExternalStringInstanceType(this, instance_type), if_bailout);
 
   // Move the pointer so that offset-wise, it looks like a sequential string.
@@ skipping 2047 matching lines @@
   // This method is used for binary op and compare feedback. These
   // vector nodes are initialized with a smi 0, so we can simply OR
   // our new feedback in place.
   Node* previous_feedback = LoadFixedArrayElement(feedback_vector, slot_id);
   Node* combined_feedback = SmiOr(previous_feedback, feedback);
   StoreFixedArrayElement(feedback_vector, slot_id, combined_feedback,
                          SKIP_WRITE_BARRIER);
 }
 
 Node* CodeStubAssembler::LoadReceiverMap(Node* receiver) {
-  Variable var_receiver_map(this, MachineRepresentation::kTagged);
-  Label load_smi_map(this, Label::kDeferred), load_receiver_map(this),
-      if_result(this);
-
-  Branch(TaggedIsSmi(receiver), &load_smi_map, &load_receiver_map);
-  Bind(&load_smi_map);
-  {
-    var_receiver_map.Bind(LoadRoot(Heap::kHeapNumberMapRootIndex));
-    Goto(&if_result);
-  }
-  Bind(&load_receiver_map);
-  {
-    var_receiver_map.Bind(LoadMap(receiver));
-    Goto(&if_result);
-  }
-  Bind(&if_result);
-  return var_receiver_map.value();
+  return Select(TaggedIsSmi(receiver),
+                [=] { return LoadRoot(Heap::kHeapNumberMapRootIndex); },
+                [=] { return LoadMap(receiver); },
+                MachineRepresentation::kTagged);
 }
 
 Node* CodeStubAssembler::TryToIntptr(Node* key, Label* miss) {
   Variable var_intptr_key(this, MachineType::PointerRepresentation());
   Label done(this, &var_intptr_key), key_is_smi(this);
   GotoIf(TaggedIsSmi(key), &key_is_smi);
   // Try to convert a heap number to a Smi.
   GotoIfNot(IsHeapNumberMap(LoadMap(key)), miss);
   {
     Node* value = LoadHeapNumberValue(key);
@@ skipping 2697 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8