[string] Move String.p.toLowerCase to CSA

src/intl.cc

 // Copyright 2013 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.
 
 #ifndef V8_INTL_SUPPORT
 #error Internationalization is expected to be enabled.
 #endif  // V8_INTL_SUPPORT
 
 #include "src/intl.h"
 
@@ skipping 123 matching lines @@
     uint16_t ch = s->Get(index);
     if (V8_UNLIKELY(IsASCIIUpper(ch) || ch & ~0x7F)) {
       return index;
     }
   }
   return length;
 }
 
 }  // namespace
 
+const uint8_t* ToLatin1LowerTable() { return &kToLower[0]; }
+
 const UChar* GetUCharBufferFromFlat(const String::FlatContent& flat,
                                     std::unique_ptr<uc16[]>* dest,
                                     int32_t length) {
   DCHECK(flat.IsFlat());
   if (flat.IsOneByte()) {
     if (!*dest) {
       dest->reset(NewArray<uc16>(length));
       CopyChars(dest->get(), flat.ToOneByteVector().start(), length);
     }
     return reinterpret_cast<const UChar*>(dest->get());
@@ skipping 40 matching lines @@
     return *result;
   }
   if (U_SUCCESS(status)) {
     DCHECK(dest_length < result->length());
     return *Handle<SeqTwoByteString>::cast(
         SeqString::Truncate(result, dest_length));
   }
   return *s;
 }
 
+// A stripped-down version of ConvertToLower that can only handle flat one-byte
+// strings and does not allocate.
+// Called from TF builtins.
+MUST_USE_RESULT Object* ConvertOneByteToLower(String* src, String* dst,
+                                              Isolate* isolate) {
+  DCHECK_EQ(src->length(), dst->length());
+  DCHECK(src->IsOneByteRepresentation());
+  DCHECK(src->IsFlat());
+  DCHECK(dst->IsSeqOneByteString());
+
+  DisallowHeapAllocation no_gc;
+
+  const int length = src->length();
+
+  const uint8_t* src_data = src->GetFlatContent().ToOneByteVector().start();
+  uint8_t* dst_data = SeqOneByteString::cast(dst)->GetChars();
+
+  bool has_changed_character = false;
+  int index_to_first_unprocessed = FastAsciiConvert<true>(
+      reinterpret_cast<char*>(dst_data),
+      reinterpret_cast<const char*>(src_data), length, &has_changed_character);
+
+  // If not ASCII, we keep the result up to index_to_first_unprocessed and
+  // process the rest.

[Camillo Bruni, 2017/05/05 11:44:26]

nit: this comment makes probably more sense before the for-loop.

[jgruber, 2017/05/05 15:26:58]

Yep, thought so as well. Done.

+  if (index_to_first_unprocessed == length) {
+    return has_changed_character ? dst : src;
+  }
+
+  for (int index = index_to_first_unprocessed; index < length; ++index) {
+    dst_data[index] = ToLatin1Lower(static_cast<uint16_t>(src_data[index]));
+  }
+
+  return dst;
+}
+
 MUST_USE_RESULT Object* ConvertToLower(Handle<String> s, Isolate* isolate) {
   if (!s->HasOnlyOneByteChars()) {
     // Use a slower implementation for strings with characters beyond U+00FF.
     return LocaleConvertCase(s, isolate, false, "");
   }
 
   int length = s->length();
 
   // We depend here on the invariant that the length of a Latin1
   // string is invariant under ToLowerCase, and the result always
   // fits in the Latin1 range in the *root locale*. It does not hold
   // for ToUpperCase even in the root locale.
 
   // Scan the string for uppercase and non-ASCII characters for strings
   // shorter than a machine-word without any memory allocation overhead.
   // TODO(jshin): Apply this to a longer input by breaking FastAsciiConvert()
   // to two parts, one for scanning the prefix with no change and the other for
   // handling ASCII-only characters.
   int index_to_first_unprocessed = length;
   const bool is_short = length < static_cast<int>(sizeof(uintptr_t));
   if (is_short) {
     index_to_first_unprocessed = FindFirstUpperOrNonAscii(s, length);
     // Nothing to do if the string is all ASCII with no uppercase.
     if (index_to_first_unprocessed == length) return *s;
   }
 
   Handle<SeqOneByteString> result =
       isolate->factory()->NewRawOneByteString(length).ToHandleChecked();
 
+  if (s->IsOneByteRepresentation()) {
+    return ConvertOneByteToLower(*s, *result, isolate);
+  }
+
   DisallowHeapAllocation no_gc;
   DCHECK(s->IsFlat());
+  DCHECK(s->IsTwoByteRepresentation());
   String::FlatContent flat = s->GetFlatContent();
+  DCHECK(flat.IsTwoByte());
+
   uint8_t* dest = result->GetChars();
-  if (flat.IsOneByte()) {
-    const uint8_t* src = flat.ToOneByteVector().start();
-    bool has_changed_character = false;
-    index_to_first_unprocessed = FastAsciiConvert<true>(
-        reinterpret_cast<char*>(dest), reinterpret_cast<const char*>(src),
-        length, &has_changed_character);
-    // If not ASCII, we keep the result up to index_to_first_unprocessed and
-    // process the rest.
-    if (index_to_first_unprocessed == length)
-      return has_changed_character ? *result : *s;
-
-    for (int index = index_to_first_unprocessed; index < length; ++index) {
-      dest[index] = ToLatin1Lower(static_cast<uint16_t>(src[index]));
-    }
-  } else {
-    if (index_to_first_unprocessed == length) {
-      DCHECK(!is_short);
-      index_to_first_unprocessed = FindFirstUpperOrNonAscii(s, length);
-    }
-    // Nothing to do if the string is all ASCII with no uppercase.
-    if (index_to_first_unprocessed == length) return *s;
-    const uint16_t* src = flat.ToUC16Vector().start();
-    CopyChars(dest, src, index_to_first_unprocessed);
-    for (int index = index_to_first_unprocessed; index < length; ++index) {
-      dest[index] = ToLatin1Lower(static_cast<uint16_t>(src[index]));
-    }
+  if (index_to_first_unprocessed == length) {
+    DCHECK(!is_short);
+    index_to_first_unprocessed = FindFirstUpperOrNonAscii(s, length);
+  }
+  // Nothing to do if the string is all ASCII with no uppercase.
+  if (index_to_first_unprocessed == length) return *s;
+  const uint16_t* src = flat.ToUC16Vector().start();
+  CopyChars(dest, src, index_to_first_unprocessed);
+  for (int index = index_to_first_unprocessed; index < length; ++index) {
+    dest[index] = ToLatin1Lower(static_cast<uint16_t>(src[index]));
   }
 
   return *result;
 }
 
 MUST_USE_RESULT Object* ConvertToUpper(Handle<String> s, Isolate* isolate) {
   int32_t length = s->length();
   if (s->HasOnlyOneByteChars() && length > 0) {
     Handle<SeqOneByteString> result =
         isolate->factory()->NewRawOneByteString(length).ToHandleChecked();
@@ skipping 106 matching lines @@
 
 void ICUTimezoneCache::Clear() {
   delete timezone_;
   timezone_ = nullptr;
   timezone_name_[0] = '\0';
   dst_timezone_name_[0] = '\0';
 }
 
 }  // namespace internal
 }  // namespace v8