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 7226 matching lines @@
  private:
   static RawOneByteString* raw(const String& str) {
     return reinterpret_cast<RawOneByteString*>(str.raw());
   }
 
   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(index == 0 || ((index >= 0) && (index < str.Length())));
     ASSERT(str.IsOneByteString());
     return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
   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 149 matching lines @@
  private:
   static RawExternalOneByteString* raw(const String& str) {
     return reinterpret_cast<RawExternalOneByteString*>(str.raw());
   }
 
   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(index == 0 || ((index >= 0) && (index < str.Length())));
     ASSERT(str.IsExternalOneByteString());
     return &(raw_ptr(str)->external_data_->data()[index]);
   }
 
   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);
@@ skipping 11 matching lines @@
 
   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);
   }
 
@@ skipping 1592 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_