Version 5.7.442.2 (cherry-pick)

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 1554 matching lines @@
 Node* CodeStubAssembler::AllocateHeapNumberWithValue(Node* value,
                                                      MutableMode mode) {
   Node* result = AllocateHeapNumber(mode);
   StoreHeapNumberValue(result, value);
   return result;
 }
 
 Node* CodeStubAssembler::AllocateSeqOneByteString(int length,
                                                   AllocationFlags flags) {
   Comment("AllocateSeqOneByteString");
-  if (length == 0) {
-    return LoadRoot(Heap::kempty_stringRootIndex);
-  }
   Node* result = Allocate(SeqOneByteString::SizeFor(length), flags);
   DCHECK(Heap::RootIsImmortalImmovable(Heap::kOneByteStringMapRootIndex));
   StoreMapNoWriteBarrier(result, Heap::kOneByteStringMapRootIndex);
   StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kLengthOffset,
                                  SmiConstant(Smi::FromInt(length)));
   // Initialize both used and unused parts of hash field slot at once.
   StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kHashFieldSlot,
                                  IntPtrConstant(String::kEmptyHashField),
                                  MachineType::PointerRepresentation());
   return result;
 }
 
 Node* CodeStubAssembler::AllocateSeqOneByteString(Node* context, Node* length,
                                                   ParameterMode mode,
                                                   AllocationFlags flags) {
   Comment("AllocateSeqOneByteString");
   Variable var_result(this, MachineRepresentation::kTagged);
 
   // Compute the SeqOneByteString size and check if it fits into new space.
-  Label if_lengthiszero(this), if_sizeissmall(this),
-      if_notsizeissmall(this, Label::kDeferred), if_join(this);
-  GotoIf(WordEqual(length, IntPtrOrSmiConstant(0, mode)), &if_lengthiszero);
-
+  Label if_sizeissmall(this), if_notsizeissmall(this, Label::kDeferred),
+      if_join(this);
   Node* raw_size = GetArrayAllocationSize(
       length, UINT8_ELEMENTS, mode,
       SeqOneByteString::kHeaderSize + kObjectAlignmentMask);
   Node* size = WordAnd(raw_size, IntPtrConstant(~kObjectAlignmentMask));
   Branch(IntPtrLessThanOrEqual(size, IntPtrConstant(kMaxRegularHeapObjectSize)),
          &if_sizeissmall, &if_notsizeissmall);
 
   Bind(&if_sizeissmall);
   {
     // Just allocate the SeqOneByteString in new space.
@@ skipping 12 matching lines @@
 
   Bind(&if_notsizeissmall);
   {
     // We might need to allocate in large object space, go to the runtime.
     Node* result = CallRuntime(Runtime::kAllocateSeqOneByteString, context,
                                ParameterToTagged(length, mode));
     var_result.Bind(result);
     Goto(&if_join);
   }
 
-  Bind(&if_lengthiszero);
-  {
-    var_result.Bind(LoadRoot(Heap::kempty_stringRootIndex));
-    Goto(&if_join);
-  }
-
   Bind(&if_join);
   return var_result.value();
 }
 
 Node* CodeStubAssembler::AllocateSeqTwoByteString(int length,
                                                   AllocationFlags flags) {
   Comment("AllocateSeqTwoByteString");
-  if (length == 0) {
-    return LoadRoot(Heap::kempty_stringRootIndex);
-  }
   Node* result = Allocate(SeqTwoByteString::SizeFor(length), flags);
   DCHECK(Heap::RootIsImmortalImmovable(Heap::kStringMapRootIndex));
   StoreMapNoWriteBarrier(result, Heap::kStringMapRootIndex);
   StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kLengthOffset,
                                  SmiConstant(Smi::FromInt(length)));
   // Initialize both used and unused parts of hash field slot at once.
   StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kHashFieldSlot,
                                  IntPtrConstant(String::kEmptyHashField),
                                  MachineType::PointerRepresentation());
   return result;
 }
 
 Node* CodeStubAssembler::AllocateSeqTwoByteString(Node* context, Node* length,
                                                   ParameterMode mode,
                                                   AllocationFlags flags) {
   Comment("AllocateSeqTwoByteString");
   Variable var_result(this, MachineRepresentation::kTagged);
 
   // Compute the SeqTwoByteString size and check if it fits into new space.
-  Label if_lengthiszero(this), if_sizeissmall(this),
-      if_notsizeissmall(this, Label::kDeferred), if_join(this);
-  GotoIf(WordEqual(length, IntPtrOrSmiConstant(0, mode)), &if_lengthiszero);
-
+  Label if_sizeissmall(this), if_notsizeissmall(this, Label::kDeferred),
+      if_join(this);
   Node* raw_size = GetArrayAllocationSize(
       length, UINT16_ELEMENTS, mode,
       SeqOneByteString::kHeaderSize + kObjectAlignmentMask);
   Node* size = WordAnd(raw_size, IntPtrConstant(~kObjectAlignmentMask));
   Branch(IntPtrLessThanOrEqual(size, IntPtrConstant(kMaxRegularHeapObjectSize)),
          &if_sizeissmall, &if_notsizeissmall);
 
   Bind(&if_sizeissmall);
   {
     // Just allocate the SeqTwoByteString in new space.
@@ skipping 14 matching lines @@
   Bind(&if_notsizeissmall);
   {
     // We might need to allocate in large object space, go to the runtime.
     Node* result =
         CallRuntime(Runtime::kAllocateSeqTwoByteString, context,
                     mode == SMI_PARAMETERS ? length : SmiFromWord(length));
     var_result.Bind(result);
     Goto(&if_join);
   }
 
-  Bind(&if_lengthiszero);
-  {
-    var_result.Bind(LoadRoot(Heap::kempty_stringRootIndex));
-    Goto(&if_join);
-  }
-
   Bind(&if_join);
   return var_result.value();
 }
 
 Node* CodeStubAssembler::AllocateSlicedString(
     Heap::RootListIndex map_root_index, Node* length, Node* parent,
     Node* offset) {
   CSA_ASSERT(this, TaggedIsSmi(length));
   Node* result = Allocate(SlicedString::kSize);
   DCHECK(Heap::RootIsImmortalImmovable(map_root_index));
@@ skipping 1282 matching lines @@
 Node* CodeStubAssembler::IsJSFunction(Node* object) {
   return HasInstanceType(object, JS_FUNCTION_TYPE);
 }
 
 Node* CodeStubAssembler::StringCharCodeAt(Node* string, Node* index,
                                           ParameterMode parameter_mode) {
   CSA_ASSERT(this, IsString(string));
   // Translate the {index} into a Word.
   index = ParameterToWord(index, parameter_mode);
 
-  // We may need to loop in case of cons, thin, or sliced strings.
+  // We may need to loop in case of cons or sliced strings.
   Variable var_index(this, MachineType::PointerRepresentation());
   Variable var_result(this, MachineRepresentation::kWord32);
   Variable var_string(this, MachineRepresentation::kTagged);
   Variable* loop_vars[] = {&var_index, &var_string};
   Label done_loop(this, &var_result), loop(this, 2, loop_vars);
   var_string.Bind(string);
   var_index.Bind(index);
   Goto(&loop);
   Bind(&loop);
   {
@@ skipping 131 matching lines @@
             // The {string} might be compressed, call the runtime.
             var_result.Bind(SmiToWord32(
                 CallRuntime(Runtime::kExternalStringGetChar,
                             NoContextConstant(), string, SmiTag(index))));
             Goto(&done_loop);
           }
         }
 
         Bind(&if_stringisnotexternal);
         {
-          Label if_stringissliced(this), if_stringisthin(this);
-          Branch(
-              Word32Equal(Word32And(string_instance_type,
-                                    Int32Constant(kStringRepresentationMask)),
-                          Int32Constant(kSlicedStringTag)),
-              &if_stringissliced, &if_stringisthin);
-          Bind(&if_stringissliced);
-          {
-            // The {string} is a SlicedString, continue with its parent.
-            Node* string_offset =
-                LoadAndUntagObjectField(string, SlicedString::kOffsetOffset);
-            Node* string_parent =
-                LoadObjectField(string, SlicedString::kParentOffset);
-            var_index.Bind(IntPtrAdd(index, string_offset));
-            var_string.Bind(string_parent);
-            Goto(&loop);
-          }
-          Bind(&if_stringisthin);
-          {
-            // The {string} is a ThinString, continue with its actual value.
-            var_string.Bind(LoadObjectField(string, ThinString::kActualOffset));
-            Goto(&loop);
-          }
+          // The {string} is a SlicedString, continue with its parent.
+          Node* string_offset =
+              LoadAndUntagObjectField(string, SlicedString::kOffsetOffset);
+          Node* string_parent =
+              LoadObjectField(string, SlicedString::kParentOffset);
+          var_index.Bind(IntPtrAdd(index, string_offset));
+          var_string.Bind(string_parent);
+          Goto(&loop);
         }
       }
     }
   }
 
   Bind(&done_loop);
   return var_result.value();
 }
 
 Node* CodeStubAssembler::StringFromCharCode(Node* code) {
@@ skipping 110 matching lines @@
 }
 
 }  // namespace
 
 Node* CodeStubAssembler::SubString(Node* context, Node* string, Node* from,
                                    Node* to) {
   Label end(this);
   Label runtime(this);
 
   Variable var_instance_type(this, MachineRepresentation::kWord32);  // Int32.
-  Variable var_representation(this, MachineRepresentation::kWord32);  // Int32.
   Variable var_result(this, MachineRepresentation::kTagged);        // String.
   Variable var_from(this, MachineRepresentation::kTagged);          // Smi.
   Variable var_string(this, MachineRepresentation::kTagged);        // String.
 
   var_instance_type.Bind(Int32Constant(0));
-  var_representation.Bind(Int32Constant(0));
   var_string.Bind(string);
   var_from.Bind(from);
 
   // Make sure first argument is a string.
 
   // Bailout if receiver is a Smi.
   GotoIf(TaggedIsSmi(string), &runtime);
 
   // Load the instance type of the {string}.
   Node* const instance_type = LoadInstanceType(string);
@@ skipping 20 matching lines @@
 
   Label single_char(this);
   GotoIf(SmiEqual(substr_length, SmiConstant(Smi::FromInt(1))), &single_char);
 
   // TODO(jgruber): Add an additional case for substring of length == 0?
 
   // Deal with different string types: update the index if necessary
   // and put the underlying string into var_string.
 
   // If the string is not indirect, it can only be sequential or external.
-  STATIC_ASSERT(kIsIndirectStringMask ==
-                (kSlicedStringTag & kConsStringTag & kThinStringTag));
+  STATIC_ASSERT(kIsIndirectStringMask == (kSlicedStringTag & kConsStringTag));
   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.
+  // The subject string is either a sliced or cons string.
 
-  Label sliced_string(this), thin_or_sliced(this);
-  var_representation.Bind(
-      Word32And(instance_type, Int32Constant(kStringRepresentationMask)));
-  GotoIf(
-      Word32NotEqual(var_representation.value(), Int32Constant(kConsStringTag)),
-      &thin_or_sliced);
+  Label sliced_string(this);
+  GotoIf(Word32NotEqual(
+             Word32And(instance_type, Int32Constant(kSlicedNotConsMask)),
+             Int32Constant(0)),
+         &sliced_string);
 
   // 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);
-  }
-
-  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);
   {
     // Fetch parent and correct start index by offset.
-    Node* sliced_offset =
-        LoadObjectField(var_string.value(), SlicedString::kOffsetOffset);
+    Node* sliced_offset = LoadObjectField(string, 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);
 
     Goto(&underlying_unpacked);
   }
@@ skipping 752 matching lines @@
   Bind(&runtime);
   {
     result.Bind(CallRuntime(Runtime::kToString, context, input));
     Goto(&done);
   }
 
   Bind(&done);
   return result.value();
 }
 
+Node* CodeStubAssembler::FlattenString(Node* string) {
+  CSA_ASSERT(this, IsString(string));
+  Variable var_result(this, MachineRepresentation::kTagged);
+  var_result.Bind(string);
+
+  Node* instance_type = LoadInstanceType(string);
+
+  // Check if the {string} is not a ConsString (i.e. already flat).
+  Label is_cons(this, Label::kDeferred), is_flat_in_cons(this), end(this);
+  {
+    GotoUnless(Word32Equal(Word32And(instance_type,
+                                     Int32Constant(kStringRepresentationMask)),
+                           Int32Constant(kConsStringTag)),
+               &end);
+
+    // Check whether the right hand side is the empty string (i.e. if
+    // this is really a flat string in a cons string).
+    Node* rhs = LoadObjectField(string, ConsString::kSecondOffset);
+    Branch(WordEqual(rhs, EmptyStringConstant()), &is_flat_in_cons, &is_cons);
+  }
+
+  // Bail out to the runtime.
+  Bind(&is_cons);
+  {
+    var_result.Bind(
+        CallRuntime(Runtime::kFlattenString, NoContextConstant(), string));
+    Goto(&end);
+  }
+
+  Bind(&is_flat_in_cons);
+  {
+    var_result.Bind(LoadObjectField(string, ConsString::kFirstOffset));
+    Goto(&end);
+  }
+
+  Bind(&end);
+  return var_result.value();
+}
+
 Node* CodeStubAssembler::JSReceiverToPrimitive(Node* context, Node* input) {
   Label if_isreceiver(this, Label::kDeferred), if_isnotreceiver(this);
   Variable result(this, MachineRepresentation::kTagged);
   Label done(this, &result);
 
   BranchIfJSReceiver(input, &if_isreceiver, &if_isnotreceiver);
 
   Bind(&if_isreceiver);
   {
     // Convert {input} to a primitive first passing Number hint.
@@ skipping 121 matching lines @@
   variable.Bind(
       IntPtrOrSmiAdd(variable.value(), IntPtrOrSmiConstant(value, mode), mode));
 }
 
 void CodeStubAssembler::Use(Label* label) {
   GotoIf(Word32Equal(Int32Constant(0), Int32Constant(1)), label);
 }
 
 void CodeStubAssembler::TryToName(Node* key, Label* if_keyisindex,
                                   Variable* var_index, Label* if_keyisunique,
-                                  Variable* var_unique, Label* if_bailout) {
+                                  Label* if_bailout) {
   DCHECK_EQ(MachineType::PointerRepresentation(), var_index->rep());
-  DCHECK_EQ(MachineRepresentation::kTagged, var_unique->rep());
   Comment("TryToName");
 
-  Label if_hascachedindex(this), if_keyisnotindex(this), if_thinstring(this);
+  Label if_hascachedindex(this), if_keyisnotindex(this);
   // Handle Smi and HeapNumber keys.
   var_index->Bind(TryToIntptr(key, &if_keyisnotindex));
   Goto(if_keyisindex);
 
   Bind(&if_keyisnotindex);
   Node* key_map = LoadMap(key);
-  var_unique->Bind(key);
   // Symbols are unique.
   GotoIf(IsSymbolMap(key_map), if_keyisunique);
   Node* key_instance_type = LoadMapInstanceType(key_map);
   // Miss if |key| is not a String.
   STATIC_ASSERT(FIRST_NAME_TYPE == FIRST_TYPE);
   GotoUnless(IsStringInstanceType(key_instance_type), if_bailout);
   // |key| is a String. Check if it has a cached array index.
   Node* hash = LoadNameHashField(key);
   Node* contains_index =
       Word32And(hash, Int32Constant(Name::kContainsCachedArrayIndexMask));
   GotoIf(Word32Equal(contains_index, Int32Constant(0)), &if_hascachedindex);
   // No cached array index. If the string knows that it contains an index,
   // then it must be an uncacheable index. Handle this case in the runtime.
   Node* not_an_index =
       Word32And(hash, Int32Constant(Name::kIsNotArrayIndexMask));
   GotoIf(Word32Equal(not_an_index, Int32Constant(0)), if_bailout);
-  // Check if we have a ThinString.
-  GotoIf(Word32Equal(key_instance_type, Int32Constant(THIN_STRING_TYPE)),
-         &if_thinstring);
-  GotoIf(
-      Word32Equal(key_instance_type, Int32Constant(THIN_ONE_BYTE_STRING_TYPE)),
-      &if_thinstring);
   // Finally, check if |key| is internalized.
   STATIC_ASSERT(kNotInternalizedTag != 0);
   Node* not_internalized =
       Word32And(key_instance_type, Int32Constant(kIsNotInternalizedMask));
   GotoIf(Word32NotEqual(not_internalized, Int32Constant(0)), if_bailout);
   Goto(if_keyisunique);
 
-  Bind(&if_thinstring);
-  var_unique->Bind(LoadObjectField(key, ThinString::kActualOffset));
-  Goto(if_keyisunique);
-
   Bind(&if_hascachedindex);
   var_index->Bind(DecodeWordFromWord32<Name::ArrayIndexValueBits>(hash));
   Goto(if_keyisindex);
 }
 
 template <typename Dictionary>
 Node* CodeStubAssembler::EntryToIndex(Node* entry, int field_index) {
   Node* entry_index = IntPtrMul(entry, IntPtrConstant(Dictionary::kEntrySize));
   return IntPtrAdd(entry_index, IntPtrConstant(Dictionary::kElementsStartIndex +
                                                field_index));
@@ skipping 829 matching lines @@
     Label if_objectisreceiver(this);
     STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
     STATIC_ASSERT(FIRST_JS_RECEIVER_TYPE == JS_PROXY_TYPE);
     Branch(
         Int32GreaterThan(instance_type, Int32Constant(FIRST_JS_RECEIVER_TYPE)),
         &if_objectisreceiver, if_bailout);
     Bind(&if_objectisreceiver);
   }
 
   Variable var_index(this, MachineType::PointerRepresentation());
-  Variable var_unique(this, MachineRepresentation::kTagged);
 
   Label if_keyisindex(this), if_iskeyunique(this);
-  TryToName(key, &if_keyisindex, &var_index, &if_iskeyunique, &var_unique,
-            if_bailout);
+  TryToName(key, &if_keyisindex, &var_index, &if_iskeyunique, if_bailout);
 
   Bind(&if_iskeyunique);
   {
     Variable var_holder(this, MachineRepresentation::kTagged);
     Variable var_holder_map(this, MachineRepresentation::kTagged);
     Variable var_holder_instance_type(this, MachineRepresentation::kWord32);
 
     Variable* merged_variables[] = {&var_holder, &var_holder_map,
                                     &var_holder_instance_type};
     Label loop(this, arraysize(merged_variables), merged_variables);
     var_holder.Bind(receiver);
     var_holder_map.Bind(map);
     var_holder_instance_type.Bind(instance_type);
     Goto(&loop);
     Bind(&loop);
     {
       Node* holder_map = var_holder_map.value();
       Node* holder_instance_type = var_holder_instance_type.value();
 
       Label next_proto(this);
       lookup_property_in_holder(receiver, var_holder.value(), holder_map,
-                                holder_instance_type, var_unique.value(),
-                                &next_proto, if_bailout);
+                                holder_instance_type, key, &next_proto,
+                                if_bailout);
       Bind(&next_proto);
 
       // Bailout if it can be an integer indexed exotic case.
       GotoIf(
           Word32Equal(holder_instance_type, Int32Constant(JS_TYPED_ARRAY_TYPE)),
           if_bailout);
 
       Node* proto = LoadMapPrototype(holder_map);
 
       Label if_not_null(this);
@@ skipping 3010 matching lines @@
   StoreObjectFieldNoWriteBarrier(result,
                                  PromiseReactionJobInfo::kDebugNameOffset,
                                  SmiConstant(kDebugNotActive));
   StoreObjectFieldNoWriteBarrier(result, PromiseReactionJobInfo::kContextOffset,
                                  context);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8