ThinStrings: fix CodeStubAssembler::SubString

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 3359 matching lines @@
                 (kSlicedStringTag & kConsStringTag & kThinStringTag));
   STATIC_ASSERT(kIsIndirectStringMask != 0);
   Label underlying_unpacked(this);
   GotoIf(Word32Equal(
              Word32And(instance_type, Int32Constant(kIsIndirectStringMask)),
              Int32Constant(0)),
          &underlying_unpacked);
 
   // The subject string is a sliced, cons, or thin string.
 
-  Label sliced_string(this), thin_or_sliced(this);
+  Label thin_string(this), thin_or_sliced(this);
   var_representation.Bind(
       Word32And(instance_type, Int32Constant(kStringRepresentationMask)));
   GotoIf(
       Word32NotEqual(var_representation.value(), Int32Constant(kConsStringTag)),
       &thin_or_sliced);
 
   // Cons string.  Check whether it is flat, then fetch first part.
   // Flat cons strings have an empty second part.
   {
     GotoIf(WordNotEqual(LoadObjectField(string, ConsString::kSecondOffset),
                         EmptyStringConstant()),
            &runtime);
 
     Node* first_string_part = LoadObjectField(string, ConsString::kFirstOffset);
     var_string.Bind(first_string_part);
     var_instance_type.Bind(LoadInstanceType(first_string_part));
     var_representation.Bind(Word32And(
         var_instance_type.value(), Int32Constant(kStringRepresentationMask)));
 
     // The loaded first part might be a thin string.
     Branch(Word32Equal(Word32And(var_instance_type.value(),
                                  Int32Constant(kIsIndirectStringMask)),
                        Int32Constant(0)),
-           &underlying_unpacked, &thin_or_sliced);
+           &underlying_unpacked, &thin_string);
   }
 
   Bind(&thin_or_sliced);
   {
-    GotoIf(Word32Equal(var_representation.value(),
-                       Int32Constant(kSlicedStringTag)),
-           &sliced_string);
-    Node* actual_string =
-        LoadObjectField(var_string.value(), ThinString::kActualOffset);
-    var_string.Bind(actual_string);
-    var_instance_type.Bind(LoadInstanceType(actual_string));
-    Goto(&underlying_unpacked);
-  }
-
-  Bind(&sliced_string);
-  {
+    GotoIf(
+        Word32Equal(var_representation.value(), Int32Constant(kThinStringTag)),
+        &thin_string);
+    // Otherwise it's a sliced string.
     // Fetch parent and correct start index by offset.
     Node* sliced_offset =
         LoadObjectField(var_string.value(), SlicedString::kOffsetOffset);
     var_from.Bind(SmiAdd(from, sliced_offset));
 
     Node* slice_parent = LoadObjectField(string, SlicedString::kParentOffset);
     var_string.Bind(slice_parent);
 
     Node* slice_parent_instance_type = LoadInstanceType(slice_parent);
     var_instance_type.Bind(slice_parent_instance_type);
 
+    // The loaded parent might be a thin string.
+    Branch(Word32Equal(Word32And(var_instance_type.value(),
+                                 Int32Constant(kIsIndirectStringMask)),
+                       Int32Constant(0)),
+           &underlying_unpacked, &thin_string);
+  }
+
+  Bind(&thin_string);
+  {
+    Node* actual_string =
+        LoadObjectField(var_string.value(), ThinString::kActualOffset);
+    var_string.Bind(actual_string);
+    var_instance_type.Bind(LoadInstanceType(actual_string));
     Goto(&underlying_unpacked);
   }
 
   // The subject string can only be external or sequential string of either
   // encoding at this point.
   Label external_string(this);
   Bind(&underlying_unpacked);
   {
     if (FLAG_string_slices) {
       Label copy_routine(this);
@@ skipping 4946 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kGlobalPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8