[json] Specialize json parser on chartype rather than bool seq_one_byte

Change-Id: I34dc911d205ab507f668bfd422eb1838f660a6bf
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1571624
Commit-Queue: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#60964}

src/api.cc

@@ -3033,9 +3033,9 @@ MaybeLocal<Value> JSON::Parse(Local<Context> context,
   i::Handle<i::String> string = Utils::OpenHandle(*json_string);
   i::Handle<i::String> source = i::String::Flatten(isolate, string);
   i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  auto maybe = source->IsSeqOneByteString()
-                   ? i::JsonParser<true>::Parse(isolate, source, undefined)
-                   : i::JsonParser<false>::Parse(isolate, source, undefined);
+  auto maybe = source->IsOneByteRepresentation()
+                   ? i::JsonParser<uint8_t>::Parse(isolate, source, undefined)
+                   : i::JsonParser<uint16_t>::Parse(isolate, source, undefined);
   Local<Value> result;
   has_pending_exception = !ToLocal<Value>(maybe, &result);
   RETURN_ON_FAILED_EXECUTION(Value);

src/builtins/builtins-json.cc

@@ -22,9 +22,9 @@ BUILTIN(JsonParse) {
                                      Object::ToString(isolate, source));
   string = String::Flatten(isolate, string);
   RETURN_RESULT_OR_FAILURE(
-      isolate, string->IsSeqOneByteString()
-                   ? JsonParser<true>::Parse(isolate, string, reviver)
-                   : JsonParser<false>::Parse(isolate, string, reviver));
+      isolate, string->IsOneByteRepresentation()
+                   ? JsonParser<uint8_t>::Parse(isolate, string, reviver)
+                   : JsonParser<uint16_t>::Parse(isolate, string, reviver));
 }
 
 // ES6 section 24.3.2 JSON.stringify.

src/json-parser.h

@@ -35,9 +35,12 @@ class JsonParseInternalizer {
 };
 
 // A simple json parser.
-template <bool seq_one_byte>
-class JsonParser {
+template <typename Char>
+class JsonParser final {
  public:
+  using SeqString = typename CharTraits<Char>::String;
+  using SeqExternalString = typename CharTraits<Char>::ExternalString;
+
   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> Parse(
       Isolate* isolate, Handle<String> source, Handle<Object> reviver) {
     Handle<Object> result;
@@ -52,7 +55,10 @@ class JsonParser {
   static const int kEndOfString = -1;
 
  private:
+  Handle<String> Internalize(int start, int length);
+
   JsonParser(Isolate* isolate, Handle<String> source);
+  ~JsonParser();
 
   // Parse a string containing a single JSON value.
   MaybeHandle<Object> ParseJson();
@@ -136,20 +142,44 @@ class JsonParser {
   static const int kInitialSpecialStringLength = 32;
   static const int kPretenureTreshold = 100 * 1024;
 
+  static void UpdatePointersCallback(v8::Isolate* v8_isolate, v8::GCType type,
+                                     v8::GCCallbackFlags flags, void* parser) {
+    reinterpret_cast<JsonParser<Char>*>(parser)->UpdatePointers();
+  }
+
+  void UpdatePointers() {
+    DisallowHeapAllocation no_gc;
+    const Char* chars = Handle<SeqString>::cast(source_)->GetChars(no_gc);
+    if (chars_ != chars) {
+      chars_ = chars;
+    }
+  }
+
  private:
+  static const bool kIsOneByte = sizeof(Char) == 1;
+
   Zone* zone() { return &zone_; }
 
   void CommitStateToJsonObject(Handle<JSObject> json_object, Handle<Map> map,
                                Vector<const Handle<Object>> properties);
 
-  Handle<String> source_;
-  int source_length_;
-  Handle<SeqOneByteString> seq_source_;
-
-  AllocationType allocation_;
   Isolate* isolate_;
   Zone zone_;
+  AllocationType allocation_;
   Handle<JSFunction> object_constructor_;
+  Handle<String> source_;
+  int offset_;
+  int length_;
+
+  // Cached pointer to the raw chars in source. In case source is on-heap, we
+  // register an UpdatePointers callback. For this reason, chars_ should never
+  // be locally cached across a possible allocation. The scope in which we
+  // cache chars has to be guarded by a DisallowHeapAllocation scope.
+  // TODO(verwaest): Move chars_ and functions that operate over chars to a
+  // separate helper class that makes it clear that all functions need to be
+  // guarded.
+  const Char* chars_;
+
   uc32 c0_;
   int position_;
 
@@ -157,9 +187,15 @@ class JsonParser {
   ZoneVector<Handle<Object>> properties_;
 };
 
+template <>
+Handle<String> JsonParser<uint8_t>::Internalize(int start, int length);
+
+template <>
+Handle<String> JsonParser<uint16_t>::Internalize(int start, int length);
+
 // Explicit instantiation declarations.
-extern template class JsonParser<true>;
-extern template class JsonParser<false>;
+extern template class JsonParser<uint8_t>;
+extern template class JsonParser<uint16_t>;
 
 }  // namespace internal
 }  // namespace v8

src/objects.cc

@@ -6292,7 +6292,7 @@ JSRegExp::Flags RegExpFlagsFromString(Isolate* isolate, Handle<String> flags,
     DisallowHeapAllocation no_gc;
     SeqOneByteString seq_flags = SeqOneByteString::cast(*flags);
     for (int i = 0; i < length; i++) {
-      JSRegExp::Flag flag = CharToFlag(seq_flags.SeqOneByteStringGet(i));
+      JSRegExp::Flag flag = CharToFlag(seq_flags.Get(i));
       // Duplicate or invalid flag.
       if (value & flag) return JSRegExp::Flags(0);
       value |= flag;

src/objects/string-inl.h

@@ -323,24 +323,22 @@ uint16_t String::Get(int index) {
   DCHECK(index >= 0 && index < length());
   switch (StringShape(*this).full_representation_tag()) {
     case kSeqStringTag | kOneByteStringTag:
-      return SeqOneByteString::cast(*this)->SeqOneByteStringGet(index);
+      return SeqOneByteString::cast(*this)->Get(index);
     case kSeqStringTag | kTwoByteStringTag:
-      return SeqTwoByteString::cast(*this)->SeqTwoByteStringGet(index);
+      return SeqTwoByteString::cast(*this)->Get(index);
     case kConsStringTag | kOneByteStringTag:
     case kConsStringTag | kTwoByteStringTag:
-      return ConsString::cast(*this)->ConsStringGet(index);
+      return ConsString::cast(*this)->Get(index);
     case kExternalStringTag | kOneByteStringTag:
-      return ExternalOneByteString::cast(*this)->ExternalOneByteStringGet(
-          index);
+      return ExternalOneByteString::cast(*this)->Get(index);
     case kExternalStringTag | kTwoByteStringTag:
-      return ExternalTwoByteString::cast(*this)->ExternalTwoByteStringGet(
-          index);
+      return ExternalTwoByteString::cast(*this)->Get(index);
     case kSlicedStringTag | kOneByteStringTag:
     case kSlicedStringTag | kTwoByteStringTag:
-      return SlicedString::cast(*this)->SlicedStringGet(index);
+      return SlicedString::cast(*this)->Get(index);
     case kThinStringTag | kOneByteStringTag:
     case kThinStringTag | kTwoByteStringTag:
-      return ThinString::cast(*this)->ThinStringGet(index);
+      return ThinString::cast(*this)->Get(index);
     default:
       break;
   }
@@ -455,7 +453,7 @@ uint32_t String::ToValidIndex(Object number) {
   return index;
 }
 
-uint16_t SeqOneByteString::SeqOneByteStringGet(int index) {
+uint8_t SeqOneByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return READ_BYTE_FIELD(*this, kHeaderSize + index * kCharSize);
 }
@@ -484,7 +482,7 @@ uc16* SeqTwoByteString::GetChars(const DisallowHeapAllocation& no_gc) {
   return reinterpret_cast<uc16*>(FIELD_ADDR(*this, kHeaderSize));
 }
 
-uint16_t SeqTwoByteString::SeqTwoByteStringGet(int index) {
+uint16_t SeqTwoByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return READ_UINT16_FIELD(*this, kHeaderSize + index * kShortSize);
 }
@@ -618,7 +616,7 @@ const uint8_t* ExternalOneByteString::GetChars() {
   return reinterpret_cast<const uint8_t*>(resource()->data());
 }
 
-uint16_t ExternalOneByteString::ExternalOneByteStringGet(int index) {
+uint8_t ExternalOneByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return GetChars()[index];
 }
@@ -652,7 +650,7 @@ void ExternalTwoByteString::set_resource(
 
 const uint16_t* ExternalTwoByteString::GetChars() { return resource()->data(); }
 
-uint16_t ExternalTwoByteString::ExternalTwoByteStringGet(int index) {
+uint16_t ExternalTwoByteString::Get(int index) {
   DCHECK(index >= 0 && index < length());
   return GetChars()[index];
 }

src/objects/string-table.h

@@ -90,7 +90,7 @@ class StringTable : public HashTable<StringTable, StringTableShape> {
   static const int kMinShrinkCapacity = kMinCapacity;
 
  private:
-  template <bool seq_one_byte>
+  template <typename char_type>
   friend class JsonParser;
 
   OBJECT_CONSTRUCTORS(StringTable, HashTable<StringTable, StringTableShape>);

src/objects/string.cc

@@ -1325,7 +1325,7 @@ void SeqTwoByteString::clear_padding() {
          SizeFor(length()) - data_size);
 }
 
-uint16_t ConsString::ConsStringGet(int index) {
+uint16_t ConsString::Get(int index) {
   DCHECK(index >= 0 && index < this->length());
 
   // Check for a flattened cons string
@@ -1354,9 +1354,9 @@ uint16_t ConsString::ConsStringGet(int index) {
   UNREACHABLE();
 }
 
-uint16_t ThinString::ThinStringGet(int index) { return actual()->Get(index); }
+uint16_t ThinString::Get(int index) { return actual()->Get(index); }
 
-uint16_t SlicedString::SlicedStringGet(int index) {
+uint16_t SlicedString::Get(int index) {
   return parent()->Get(offset() + index);
 }
 

src/objects/string.h

@@ -507,7 +507,7 @@ class SeqOneByteString : public SeqString {
   static const bool kHasOneByteEncoding = true;
 
   // Dispatched behavior.
-  inline uint16_t SeqOneByteStringGet(int index);
+  inline uint8_t Get(int index);
   inline void SeqOneByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
@@ -548,7 +548,7 @@ class SeqTwoByteString : public SeqString {
   static const bool kHasOneByteEncoding = false;
 
   // Dispatched behavior.
-  inline uint16_t SeqTwoByteStringGet(int index);
+  inline uint16_t Get(int index);
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
@@ -610,7 +610,7 @@ class ConsString : public String {
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Dispatched behavior.
-  V8_EXPORT_PRIVATE uint16_t ConsStringGet(int index);
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   DECL_CAST(ConsString)
 
@@ -642,7 +642,7 @@ class ThinString : public String {
   inline void set_actual(String s,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
-  V8_EXPORT_PRIVATE uint16_t ThinStringGet(int index);
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   DECL_CAST(ThinString)
   DECL_VERIFIER(ThinString)
@@ -676,7 +676,7 @@ class SlicedString : public String {
   inline void set_offset(int offset);
 
   // Dispatched behavior.
-  V8_EXPORT_PRIVATE uint16_t SlicedStringGet(int index);
+  V8_EXPORT_PRIVATE uint16_t Get(int index);
 
   DECL_CAST(SlicedString)
 
@@ -758,7 +758,7 @@ class ExternalOneByteString : public ExternalString {
   inline const uint8_t* GetChars();
 
   // Dispatched behavior.
-  inline uint16_t ExternalOneByteStringGet(int index);
+  inline uint8_t Get(int index);
 
   DECL_CAST(ExternalOneByteString)
 
@@ -793,7 +793,7 @@ class ExternalTwoByteString : public ExternalString {
   inline const uint16_t* GetChars();
 
   // Dispatched behavior.
-  inline uint16_t ExternalTwoByteStringGet(int index);
+  inline uint16_t Get(int index);
 
   // For regexp code.
   inline const uint16_t* ExternalTwoByteStringGetData(unsigned start);
@@ -895,6 +895,21 @@ class StringCharacterStream {
   DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
 };
 
+template <typename Char>
+struct CharTraits;
+
+template <>
+struct CharTraits<uint8_t> {
+  using String = SeqOneByteString;
+  using ExternalString = ExternalOneByteString;
+};
+
+template <>
+struct CharTraits<uint16_t> {
+  using String = SeqTwoByteString;
+  using ExternalString = ExternalTwoByteString;
+};
+
 }  // namespace internal
 }  // namespace v8
 

src/parsing/scanner-character-streams.cc

@@ -49,21 +49,6 @@ namespace {
 const unibrow::uchar kUtf8Bom = 0xFEFF;
 }  // namespace
 
-template <typename Char>
-struct CharTraits;
-
-template <>
-struct CharTraits<uint8_t> {
-  using String = SeqOneByteString;
-  using ExternalString = ExternalOneByteString;
-};
-
-template <>
-struct CharTraits<uint16_t> {
-  using String = SeqTwoByteString;
-  using ExternalString = ExternalTwoByteString;
-};
-
 template <typename Char>
 struct Range {
   const Char* start;

test/mjsunit/json-parse-slice.js

+// Copyright 2019 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.
+
+var s = 'abcabcabcabcabc["possibly a sliced string"]'.slice(15)
+assertEquals(["possibly a sliced string"], JSON.parse(s));