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

runtime/vm/object.h

 // 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.
 
 #ifndef RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 7148 matching lines @@
   static const RawOneByteString* raw_ptr(const String& str) {
     return reinterpret_cast<const RawOneByteString*>(str.raw_ptr());
   }
 
   static uint8_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
     return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
+  static uint8_t* DataStart(const String& str) {
+    ASSERT(str.IsOneByteString());
+    return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[0];
+  }
+
   static RawOneByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference);
 
   friend class Class;
   friend class String;
   friend class Symbols;
   friend class ExternalOneByteString;
   friend class SnapshotReader;
   friend class StringHasher;
+  friend class Utf8;
 };
 
 class TwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     return raw_ptr(str)->data()[index];
   }
 
@@ skipping 85 matching lines @@
   static const RawTwoByteString* raw_ptr(const String& str) {
     return reinterpret_cast<const RawTwoByteString*>(str.raw_ptr());
   }
 
   static uint16_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
+  static uint16_t* DataStart(const String& str) {
+    ASSERT(str.IsTwoByteString());
+    return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[0];
+  }
+
   static RawTwoByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
@@ skipping 46 matching lines @@
   static const RawExternalOneByteString* raw_ptr(const String& str) {
     return reinterpret_cast<const RawExternalOneByteString*>(str.raw_ptr());
   }
 
   static const uint8_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsExternalOneByteString());
     return &(raw_ptr(str)->external_data_->data()[index]);
   }
 
+  static const uint8_t* DataStart(const String& str) {
+    ASSERT(str.IsExternalOneByteString());
+    return &(raw_ptr(str)->external_data_->data()[0]);
+  }
+
   static void SetExternalData(const String& str,
                               ExternalStringData<uint8_t>* data) {
     ASSERT(str.IsExternalOneByteString());
     ASSERT(!Isolate::Current()->heap()->Contains(
         reinterpret_cast<uword>(data->data())));
     str.StoreNonPointer(&raw_ptr(str)->external_data_, data);
   }
 
   static void Finalize(void* isolate_callback_data,
                        Dart_WeakPersistentHandle handle,
                        void* peer);
 
   static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind,
                                             bool as_reference);
 
   static intptr_t NextFieldOffset() {
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
+  friend class Utf8;
 };
 
 class ExternalTwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     NoSafepointScope no_safepoint;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
@@ skipping 32 matching lines @@
   static const RawExternalTwoByteString* raw_ptr(const String& str) {
     return reinterpret_cast<const RawExternalTwoByteString*>(str.raw_ptr());
   }
 
   static const uint16_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsExternalTwoByteString());
     return &(raw_ptr(str)->external_data_->data()[index]);
   }
 
+  static const uint16_t* DataStart(const String& str) {
+    ASSERT(str.IsExternalTwoByteString());
+    return &(raw_ptr(str)->external_data_->data()[0]);
+  }
+
   static void SetExternalData(const String& str,
                               ExternalStringData<uint16_t>* data) {
     ASSERT(str.IsExternalTwoByteString());
     ASSERT(!Isolate::Current()->heap()->Contains(
         reinterpret_cast<uword>(data->data())));
     str.StoreNonPointer(&raw_ptr(str)->external_data_, data);
   }
 
   static void Finalize(void* isolate_callback_data,
                        Dart_WeakPersistentHandle handle,
@@ skipping 1507 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_