- Add functionality to morph a string into an external string

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/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 456 matching lines @@
   // pre-allocated in the vm isolate also.
   cls = Dart::vm_isolate()->object_store()->array_class();
   str = Symbols::ObjectArray();
   cls.set_name(str);
   cls = Dart::vm_isolate()->object_store()->one_byte_string_class();
   str = Symbols::OneByteString();
   cls.set_name(str);
 }
 
 
+// Make unused space in an object whose type has been transformed safe
+// for traversing during GC.
+// The unused part of the transformed object is marked as an Array
+// object or a regular Object so that it can be traversed during garbage
+// collection.
+void Object::MakeUnusedSpaceTraversable(const Object& obj,
+                                        intptr_t original_size,
+                                        intptr_t used_size) {
+  ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
+  ASSERT(!obj.IsNull());
+  ASSERT(original_size >= used_size);
+  if (original_size > used_size) {
+    intptr_t leftover_size = original_size - used_size;
+
+    uword addr = RawObject::ToAddr(obj.raw()) + used_size;
+    if (leftover_size >= Array::InstanceSize(0)) {
+      // As we have enough space to use an array object, update the leftover
+      // space as an Array object.
+      RawArray* raw = reinterpret_cast<RawArray*>(RawObject::FromAddr(addr));
+      uword tags = 0;
+      tags = RawObject::SizeTag::update(leftover_size, tags);
+      tags = RawObject::ClassIdTag::update(kArrayCid, tags);
+      raw->ptr()->tags_ = tags;
+      intptr_t leftover_len =
+          ((leftover_size - Array::InstanceSize(0)) / kWordSize);
+      ASSERT(Array::InstanceSize(leftover_len) == leftover_size);
+      raw->ptr()->tags_ = tags;
+      raw->ptr()->length_ = Smi::New(leftover_len);
+    } else {
+      // Update the leftover space as a basic object.
+      ASSERT(leftover_size == Object::InstanceSize());
+      RawObject* raw =
+          reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
+      uword tags = 0;
+      tags = RawObject::SizeTag::update(leftover_size, tags);
+      tags = RawObject::ClassIdTag::update(kInstanceCid, tags);
+      raw->ptr()->tags_ = tags;
+    }
+  }
+}
+
+
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(Symbols::New(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
   return cls.raw();
 }
 
@@ skipping 9890 matching lines @@
     if (obj.Length() > 0) {
       memmove(utf8_array, OneByteString::CharAddr(obj, 0), obj.Length());
     }
   } else {
     ASSERT(array_len >= Utf8::Length(*this));
     Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
   }
 }
 
 
+static void AddFinalizer(const Object& referent,
+                         void* peer,
+                         Dart_WeakPersistentHandleFinalizer callback) {
+  ASSERT(callback != NULL);
+  ApiState* state = Isolate::Current()->api_state();
+  ASSERT(state != NULL);
+  FinalizablePersistentHandle* weak_ref =
+      state->weak_persistent_handles().AllocateHandle();
+  weak_ref->set_raw(referent);
+  weak_ref->set_peer(peer);
+  weak_ref->set_callback(callback);
+}
+
+
+RawString* String::MakeExternal(void* array,
+                                intptr_t length,
+                                void* peer,
+                                Dart_PeerFinalizer cback) const {
+  ASSERT(array != NULL);
+  intptr_t str_length = this->Length();
+  ASSERT(length >= (str_length * this->CharSize()));
+  intptr_t class_id = raw()->GetClassId();
+  intptr_t used_size = 0;
+  intptr_t original_size = 0;
+  uword tags = 0;
+  NoGCScope no_gc;
+
+  if (class_id == kOneByteStringCid) {
+    used_size = ExternalOneByteString::InstanceSize();
+    original_size = OneByteString::InstanceSize(str_length);
+    ASSERT(original_size >= used_size);
+
+    // Copy the data into the external array.
+    if (str_length > 0) {
+      memmove(array, OneByteString::CharAddr(*this, 0), str_length);
+    }
+
+    // Update the class information of the object.
+    const intptr_t class_id = kExternalOneByteStringCid;
+    tags = RawObject::SizeTag::update(used_size, tags);
+    tags = RawObject::ClassIdTag::update(class_id, tags);
+    raw_ptr()->tags_ = tags;
+    const String& result = String::Handle(this->raw());
+    ExternalStringData<uint8_t>* ext_data = new ExternalStringData<uint8_t>(
+        reinterpret_cast<const uint8_t*>(array), peer, cback);
+    result.SetLength(str_length);
+    result.SetHash(0);
+    ExternalOneByteString::SetExternalData(result, ext_data);
+    AddFinalizer(result, ext_data, ExternalOneByteString::Finalize);
+  } else {
+    ASSERT(class_id == kTwoByteStringCid);
+    used_size = ExternalTwoByteString::InstanceSize();
+    original_size = TwoByteString::InstanceSize(str_length);
+    ASSERT(original_size >= used_size);
+
+    // Copy the data into the external array.
+    if (str_length > 0) {
+      memmove(array,
+              TwoByteString::CharAddr(*this, 0),
+              (str_length * kTwoByteChar));
+    }
+
+    // Update the class information of the object.
+    const intptr_t class_id = kExternalTwoByteStringCid;
+    tags = RawObject::SizeTag::update(used_size, tags);
+    tags = RawObject::ClassIdTag::update(class_id, tags);
+    raw_ptr()->tags_ = tags;
+    const String& result = String::Handle(this->raw());
+    ExternalStringData<uint16_t>* ext_data = new ExternalStringData<uint16_t>(
+        reinterpret_cast<const uint16_t*>(array), peer, cback);
+    result.SetLength(str_length);
+    result.SetHash(0);
+    ExternalTwoByteString::SetExternalData(result, ext_data);
+    AddFinalizer(result, ext_data, ExternalTwoByteString::Finalize);
+  }
+
+  // If there is any left over space fill it with either an Array object or
+  // just a plain object (depending on the amount of left over space) so
+  // that it can be traversed over successfully during garbage collection.
+  Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
+
+  return this->raw();
+}
+
+
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   bool has_mapping = false;
   int32_t dst_max = 0;
   intptr_t len = str.Length();
   // TODO(cshapiro): assume a transform is required, rollback if not.
   for (intptr_t i = 0; i < len; ++i) {
     int32_t src = str.CharAt(i);
@@ skipping 370 matching lines @@
   const String& result = String::Handle(TwoByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(ch >= 0 && ch <= 0xFFFF);
     *CharAddr(result, i) = ch;
   }
   return TwoByteString::raw(result);
 }
 
 
-static void AddFinalizer(const Object& referent,
-                         void* peer,
-                         Dart_WeakPersistentHandleFinalizer callback) {
-  ASSERT(callback != NULL);
-  ApiState* state = Isolate::Current()->api_state();
-  ASSERT(state != NULL);
-  FinalizablePersistentHandle* weak_ref =
-      state->weak_persistent_handles().AllocateHandle();
-  weak_ref->set_raw(referent);
-  weak_ref->set_peer(peer);
-  weak_ref->set_callback(callback);
-}
-
-
 RawExternalOneByteString* ExternalOneByteString::New(
     const uint8_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
     Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->
          external_one_byte_string_class() != Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
@@ skipping 209 matching lines @@
   array.raw_ptr()->tags_ = tags;
   array.SetLength(used_len);
 
   // Null the GrowableObjectArray, we are removing it's backing array.
   growable_array.SetLength(0);
   growable_array.SetData(new_array);
 
   // If there is any left over space fill it with either an Array object or
   // just a plain object (depending on the amount of left over space) so
   // that it can be traversed over successfully during garbage collection.
-  if (capacity_size != used_size) {
-    ASSERT(capacity_len > used_len);
-    intptr_t leftover_size = capacity_size - used_size;
+  Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
 
-    uword addr = RawObject::ToAddr(array.raw()) + used_size;
-    if (leftover_size >= Array::InstanceSize(0)) {
-      // As we have enough space to use an array object, update the leftover
-      // space as an Array object.
-      RawArray* raw = reinterpret_cast<RawArray*>(RawObject::FromAddr(addr));
-      tags = 0;
-      tags = RawObject::SizeTag::update(leftover_size, tags);
-      tags = RawObject::ClassIdTag::update(kArrayCid, tags);
-      raw->ptr()->tags_ = tags;
-      intptr_t leftover_len =
-          ((leftover_size - Array::InstanceSize(0)) / kWordSize);
-      raw->ptr()->tags_ = tags;
-      raw->ptr()->length_ = Smi::New(leftover_len);
-    } else {
-      // Update the leftover space as a basic object.
-      ASSERT(leftover_size == Object::InstanceSize());
-      RawObject* raw = reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
-      tags = 0;
-      tags = RawObject::SizeTag::update(leftover_size, tags);
-      tags = RawObject::ClassIdTag::update(kInstanceCid, tags);
-      raw->ptr()->tags_ = tags;
-    }
-  }
   return array.raw();
 }
 
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
                                        Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->immutable_array_class() !=
          Class::null());
   return reinterpret_cast<RawImmutableArray*>(Array::New(kClassId, len, space));
 }
@@ skipping 946 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart