VM: Speed up output of UTF8 for 1-byte strings.

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/become.h"
 #include "vm/bit_vector.h"
@@ skipping 19839 matching lines @@
 RawString* String::FromUTF8(const uint8_t* utf8_array,
                             intptr_t array_len,
                             Heap::Space space) {
   Utf8::Type type;
   intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
   if (type == Utf8::kLatin1) {
     const String& strobj = String::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoSafepointScope no_safepoint;
       Utf8::DecodeToLatin1(utf8_array, array_len,
-                           OneByteString::CharAddr(strobj, 0), len);
+                           OneByteString::DataStart(strobj), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSupplementary));
   const String& strobj = String::Handle(TwoByteString::New(len, space));
   NoSafepointScope no_safepoint;
-  Utf8::DecodeToUTF16(utf8_array, array_len, TwoByteString::CharAddr(strobj, 0),
+  Utf8::DecodeToUTF16(utf8_array, array_len, TwoByteString::DataStart(strobj),
                       len);
   return strobj.raw();
 }
 
 RawString* String::FromLatin1(const uint8_t* latin1_array,
                               intptr_t array_len,
                               Heap::Space space) {
   return OneByteString::New(latin1_array, array_len, space);
 }
 
@@ skipping 416 matching lines @@
   if (is_one_byte_string) {
     result = OneByteString::New(length, space);
   } else {
     result = TwoByteString::New(length, space);
   }
   String::Copy(result, 0, str, begin_index, length);
   return result.raw();
 }
 
 const char* String::ToCString() const {
-  if (IsOneByteString()) {
-    // Quick conversion if OneByteString contains only ASCII characters.
-    intptr_t len = Length();
-    if (len == 0) {
-      return "";
-    }
-    Zone* zone = Thread::Current()->zone();
-    uint8_t* result = zone->Alloc<uint8_t>(len + 1);
-    NoSafepointScope no_safepoint;
-    const uint8_t* original_str = OneByteString::CharAddr(*this, 0);
-    for (intptr_t i = 0; i < len; i++) {
-      if (original_str[i] <= Utf8::kMaxOneByteChar) {
-        result[i] = original_str[i];
-      } else {
-        len = -1;
-        break;
-      }
-    }
-    if (len > 0) {
-      result[len] = 0;
-      return reinterpret_cast<const char*>(result);
-    }
-  }
   const intptr_t len = Utf8::Length(*this);
   Zone* zone = Thread::Current()->zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<const char*>(result);
 }
 
 char* String::ToMallocCString() const {
-  if (IsOneByteString()) {
-    // Quick conversion if OneByteString contains only ASCII characters.
-    intptr_t len = Length();
-    uint8_t* result = reinterpret_cast<uint8_t*>(malloc(len + 1));
-    NoSafepointScope no_safepoint;
-    const uint8_t* original_str = OneByteString::CharAddr(*this, 0);
-    for (intptr_t i = 0; i < len; i++) {
-      if (original_str[i] <= Utf8::kMaxOneByteChar) {
-        result[i] = original_str[i];
-      } else {
-        len = -1;
-        break;
-      }
-    }
-    if (len > 0) {
-      result[len] = 0;
-      return reinterpret_cast<char*>(result);
-    }
-  }
   const intptr_t len = Utf8::Length(*this);
   uint8_t* result = reinterpret_cast<uint8_t*>(malloc(len + 1));
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<char*>(result);
 }
 
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
   ASSERT(array_len >= Utf8::Length(*this));
   Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
@@ skipping 274 matching lines @@
     return result;
   }
 }
 
 RawOneByteString* OneByteString::New(const uint8_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   if (len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(CharAddr(result, 0), characters, len);
+    memmove(DataStart(result), characters, len);
   }
   return OneByteString::raw(result);
 }
 
 RawOneByteString* OneByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < len; ++i) {
@@ skipping 23 matching lines @@
 }
 
 RawOneByteString* OneByteString::New(const String& other_one_byte_string,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_one_byte_string.IsOneByteString());
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(OneByteString::CharAddr(result, 0),
+    memmove(OneByteString::DataStart(result),
             OneByteString::CharAddr(other_one_byte_string, other_start_index),
             other_len);
   }
   return OneByteString::raw(result);
 }
 
 RawOneByteString* OneByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(OneByteString::CharAddr(result, 0),
+    memmove(OneByteString::DataStart(result),
             other_typed_data.DataAddr(other_start_index), other_len);
   }
   return OneByteString::raw(result);
 }
 
 RawOneByteString* OneByteString::New(const ExternalTypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(OneByteString::CharAddr(result, 0),
+    memmove(OneByteString::DataStart(result),
             other_typed_data.DataAddr(other_start_index), other_len);
   }
   return OneByteString::raw(result);
 }
 
 RawOneByteString* OneByteString::Concat(const String& str1,
                                         const String& str2,
                                         Heap::Space space) {
   intptr_t len1 = str1.Length();
   intptr_t len2 = str2.Length();
@@ skipping 129 matching lines @@
   return TwoByteString::raw(result);
 }
 
 RawTwoByteString* TwoByteString::New(const uint16_t* utf16_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT(array_len > 0);
   const String& result = String::Handle(TwoByteString::New(array_len, space));
   {
     NoSafepointScope no_safepoint;
-    memmove(CharAddr(result, 0), utf16_array, (array_len * 2));
+    memmove(DataStart(result), utf16_array, (array_len * 2));
   }
   return TwoByteString::raw(result);
 }
 
 RawTwoByteString* TwoByteString::New(intptr_t utf16_len,
                                      const int32_t* utf32_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT((array_len > 0) && (utf16_len >= array_len));
   const String& result = String::Handle(TwoByteString::New(utf16_len, space));
@@ skipping 22 matching lines @@
   return TwoByteString::raw(result);
 }
 
 RawTwoByteString* TwoByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(TwoByteString::New(other_len, space));
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(TwoByteString::CharAddr(result, 0),
+    memmove(TwoByteString::DataStart(result),
             other_typed_data.DataAddr(other_start_index),
             other_len * sizeof(uint16_t));
   }
   return TwoByteString::raw(result);
 }
 
 RawTwoByteString* TwoByteString::New(const ExternalTypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(TwoByteString::New(other_len, space));
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
-    memmove(TwoByteString::CharAddr(result, 0),
+    memmove(TwoByteString::DataStart(result),
             other_typed_data.DataAddr(other_start_index),
             other_len * sizeof(uint16_t));
   }
   return TwoByteString::raw(result);
 }
 
 RawTwoByteString* TwoByteString::Concat(const String& str1,
                                         const String& str2,
                                         Heap::Space space) {
   intptr_t len1 = str1.Length();
@@ skipping 1588 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart