Changes to set up the object tag bits

vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2118 matching lines @@
       AbstractTypeArguments::Handle(other.arguments()));
 }
 
 
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     // TODO(regis): Should we add null_class_, void_class_, dynamic_class_ to

[regis, 2011/12/14 02:53:36]

Feel free to remove this TODO, as discussed.

[siva, 2011/12/14 18:04:39]

Done.

     // the object store, remove all types from the object store, and replace
     // the test above by an assert?
     return this->raw();
   }
-  const intptr_t canonical_types_len = canonical_types.Length();
-  // Linear search to see whether this type is already present in the
-  // list of canonicalized types.
-  Type& type = Type::Handle();
-  intptr_t index = 0;
-  while (index < canonical_types_len) {
-    type ^= canonical_types.At(index);
-    if (type.IsNull()) {
-      break;
+  if (!IsCanonical()) {
+    const intptr_t canonical_types_len = canonical_types.Length();
+    // Linear search to see whether this type is already present in the
+    // list of canonicalized types.
+    Type& type = Type::Handle();
+    intptr_t index = 0;
+    while (index < canonical_types_len) {
+      type ^= canonical_types.At(index);
+      if (type.IsNull()) {
+        break;
+      }
+      if (!type.IsFinalized()) {
+        ASSERT((index == 0) && cls.IsSignatureClass());
+        index++;
+        continue;
+      }
+      if (this->Equals(type)) {
+        return type.raw();
+      }
+      index++;
     }
-    if (!type.IsFinalized()) {
-      ASSERT((index == 0) && cls.IsSignatureClass());
-      index++;
-      continue;
+    // The type needs to be added to the list. Grow the list if it is full.
+    if (index == canonical_types_len) {
+      const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
+      const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
+      const Array& new_canonical_types =
+          Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
+      cls.set_canonical_types(new_canonical_types);
+      new_canonical_types.SetAt(index, *this);
+    } else {
+      canonical_types.SetAt(index, *this);
     }
-    if (this->Equals(type)) {
-      return type.raw();
-    }
-    index++;
-  }
-  // The type needs to be added to the list. Grow the list if it is full.
-  if (index == canonical_types_len) {
-    const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
-    const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
-    const Array& new_canonical_types =
-        Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
-    cls.set_canonical_types(new_canonical_types);
-    new_canonical_types.SetAt(index, *this);
-  } else {
-    canonical_types.SetAt(index, *this);
+    SetCanonical();
   }
   return this->raw();
 }
 
 
 void Type::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
@@ skipping 331 matching lines @@
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
   return *TypeAddr(index);
 }
 
 
 void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
-  ASSERT(!is_canonical());
+  ASSERT(!IsCanonical());
   // TODO(iposva): Add storing NoGCScope.
   *TypeAddr(index) = value.raw();
 }
 
 
 bool TypeArguments::IsResolved() const {
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
@@ skipping 65 matching lines @@
 
   const Class& type_arguments_class =
       Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(type_arguments_class,
                                       TypeArguments::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.set_is_canonical(false);
     // Length must be set before we start storing into the array.
     result.SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       *result.TypeAddr(i) = Type::null();
     }
   }
   return result.raw();
 }
 
 
 
 RawAbstractType** TypeArguments::TypeAddr(intptr_t index) const {
   // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types_[index];
 }
 
 
 void TypeArguments::SetLength(intptr_t value) {
-  ASSERT(!is_canonical());
+  ASSERT(!IsCanonical());
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   raw_ptr()->length_ = Smi::New(value);
 }
 
 
 RawAbstractTypeArguments* TypeArguments::Canonicalize() const {
-  if (IsNull() || is_canonical() || !IsInstantiated()) {
+  if (IsNull() || IsCanonical() || !IsInstantiated()) {
     return this->raw();
   }
   ObjectStore* object_store = Isolate::Current()->object_store();
   // 'table' must be null terminated.
   Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   intptr_t index = 0;
   TypeArguments& other = TypeArguments::Handle();
   other ^= table.At(index);
   while (!other.IsNull()) {
     if (this->Equals(other)) {
       return other.raw();
     }
     other ^= table.At(++index);
   }
   // Not found. Add 'this' to table.
   if (index == table.Length() - 1) {
     table = Array::Grow(table, table.Length() + 4, Heap::kOld);
     object_store->set_canonical_type_arguments(table);
   }
   table.SetAt(index, *this);
-  this->set_is_canonical(true);
+  SetCanonical();
   return this->raw();
 }
 
 
-bool TypeArguments::is_canonical() const {
-  return raw_ptr()->is_canonical_;
-}
-
-
-void TypeArguments::set_is_canonical(bool value) const {
-  raw_ptr()->is_canonical_ = value;
-}
-
-
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
@@ skipping 2316 matching lines @@
     return false;
   }
 
   {
     NoGCScope no_gc;
     // Raw bits compare.
     const intptr_t instance_size = Class::Handle(this->clazz()).instance_size();
     ASSERT(instance_size != 0);
     uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
     uword other_addr = reinterpret_cast<uword>(other.raw_ptr());
-    for (intptr_t offset = 0; offset < instance_size; offset += kWordSize) {
+    for (intptr_t offset = sizeof(RawObject);
+         offset < instance_size;
+         offset += kWordSize) {
       if ((*reinterpret_cast<RawObject**>(this_addr + offset)) !=
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
         return false;
       }
     }
   }
   return true;
 }
 
 
 RawInstance* Instance::Canonicalize() const {
   ASSERT(!IsNull());
-  const Class& cls = Class::Handle(this->clazz());
-  Array& constants = Array::Handle(cls.constants());
-  const intptr_t constants_len = constants.Length();
-  // Linear search to see whether this value is already present in the
-  // list of canonicalized constants.
-  Instance& norm_value = Instance::Handle();
-  intptr_t index = 0;
-  while (index < constants_len) {
-    norm_value ^= constants.At(index);
-    if (norm_value.IsNull()) {
-      break;
+  if (!IsCanonical()) {
+    const Class& cls = Class::Handle(this->clazz());
+    Array& constants = Array::Handle(cls.constants());
+    const intptr_t constants_len = constants.Length();
+    // Linear search to see whether this value is already present in the
+    // list of canonicalized constants.
+    Instance& norm_value = Instance::Handle();
+    intptr_t index = 0;
+    while (index < constants_len) {
+      norm_value ^= constants.At(index);
+      if (norm_value.IsNull()) {
+        break;
+      }
+      if (this->Equals(norm_value)) {
+        return norm_value.raw();
+      }
+      index++;
     }
-    if (this->Equals(norm_value)) {
-      return norm_value.raw();
+    // The value needs to be added to the list. Grow the list if
+    // it is full.
+    // TODO(srdjan): Copy instance into old space if canonicalized?
+    if (index == constants_len) {
+      const intptr_t kInitialConstLength = 4;
+      const intptr_t old_length = constants.Length();
+      const intptr_t new_length =
+          (old_length == 0) ? kInitialConstLength : old_length * 2;
+      const Array& new_constants =
+          Array::Handle(Array::Grow(constants, new_length, Heap::kOld));
+      cls.set_constants(new_constants);
+      new_constants.SetAt(index, *this);
+    } else {
+      constants.SetAt(index, *this);
     }
-    index++;
-  }
-  // The value needs to be added to the list. Grow the list if
-  // it is full.
-  // TODO(srdjan): Copy instance into old space if canonicalized?
-  if (index == constants_len) {
-    const intptr_t kInitialConstLength = 4;
-    const intptr_t old_length = constants.Length();
-    const intptr_t new_length =
-        (old_length == 0) ? kInitialConstLength : old_length * 2;
-    const Array& new_constants =
-        Array::Handle(Array::Grow(constants, new_length, Heap::kOld));
-    cls.set_constants(new_constants);
-    new_constants.SetAt(index, *this);
-  } else {
-    constants.SetAt(index, *this);
+    SetCanonical();
   }
   return this->raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
@@ skipping 775 matching lines @@
   for (int i = 0; i < slen; i++) {
     if (this->CharAt(i) != other.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawInstance* String::Canonicalize() const {
+  if (IsCanonical()) {
+    return this->raw();
+  }
   return NewSymbol(*this);
 }
 
 
-bool String::IsSymbol() const {
-  if (!HasHash()) {
-    // All symbols have had their hash calculated.
-    return false;
-  }
-
-  // Get the hash for this string.
-  intptr_t hash = Hash();
-
-  ObjectStore* object_store = Isolate::Current()->object_store();
-  const Array& symbol_table = Array::Handle(object_store->symbol_table());
-  // Last element of the array is the number of used elements.
-  intptr_t table_size = symbol_table.Length() - 1;
-  intptr_t index = hash % table_size;
-
-  // Try to find this string object in the symbol table. The symbol table is
-  // never entirely full so this loop will terminate.
-  String& symbol = String::Handle();
-  symbol ^= symbol_table.At(index);
-  while (!symbol.IsNull() && (raw_ptr() != symbol.raw_ptr())) {
-    index = (index + 1) % table_size;  // Move to next element.
-    symbol ^= symbol_table.At(index);
-  }
-
-  // This string is a symbol if we found a matching entry.
-  return !symbol.IsNull();
-}
-
-
 RawString* String::New(const char* str, Heap::Space space) {
   intptr_t width = 0;
   intptr_t len = Utf8::CodePointCount(str, &width);
   if (width == 1) {
     const OneByteString& onestr
         = OneByteString::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoGCScope no_gc;
       Utf8::Decode(str, onestr.CharAddr(0), len);
     }
@@ skipping 289 matching lines @@
   new_symbol_table.SetAt(new_table_size, new_element);
   // Remember the new symbol table now.
   Isolate::Current()->object_store()->set_symbol_table(new_symbol_table);
 }
 
 
 static void InsertIntoSymbolTable(const Array& symbol_table,
                                   const String& symbol,
                                   intptr_t index,
                                   intptr_t table_size) {
+  symbol.SetCanonical();  // Mark object as being canonical.
   symbol_table.SetAt(index, symbol);  // Remember the new symbol.
   Smi& used = Smi::Handle();
   used ^= symbol_table.At(table_size);
   intptr_t used_elements = used.Value() + 1;  // One more element added.
   used = Smi::New(used_elements);
   symbol_table.SetAt(table_size, used);  // Update used count.
 
   // Rehash if symbol_table is 75% full.
   if (used_elements > ((table_size / 4) * 3)) {
     GrowSymbolTable(symbol_table, table_size);
@@ skipping 54 matching lines @@
   ASSERT(symbol.IsSymbol());
   return symbol.raw();
 }
 
 template RawString* String::NewSymbol(const uint8_t* characters, intptr_t len);
 template RawString* String::NewSymbol(const uint16_t* characters, intptr_t len);
 template RawString* String::NewSymbol(const uint32_t* characters, intptr_t len);
 
 
 RawString* String::NewSymbol(const String& str) {
+  if (str.IsSymbol()) {
+    return str.raw();
+  }
   return NewSymbol(str, 0, str.Length());
 }
 
 
 RawString* String::NewSymbol(const String& str,
                              intptr_t begin_index,
                              intptr_t len) {
   ASSERT(begin_index >= 0);
   ASSERT(len >= 0);
   ASSERT((begin_index + len) <= str.Length());
@@ skipping 1056 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart