- Add extra checking when validating objects.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1383 matching lines @@
       ASSERT(object_store->stacktrace_class() != Class::null());
       return object_store->stacktrace_class();
     case kJSRegExp:
       ASSERT(object_store->jsregexp_class() != Class::null());
       return object_store->jsregexp_class();
     case kClosure:
       return Class::New<Closure>();
     case kInstance:
       return Class::New<Instance>();
     default:
+      OS::Print("Class::GetClass kind unknown: %d\n", kind);
       UNREACHABLE();
   }
   return Class::null();
 }
 
 
 RawClass* Class::NewNativeWrapper(Library* library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library->LookupClass(name));
@@ skipping 1738 matching lines @@
 
 
 
 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) {
+void TypeArguments::SetLength(intptr_t value) const {
   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() || IsCanonical() || !IsInstantiated()) {
     return this->raw();
@@ skipping 5473 matching lines @@
 
 RawArray* Array::Empty() {
   return Isolate::Current()->object_store()->empty_array();
 }
 
 
 RawArray* Array::MakeArray(const GrowableObjectArray& growable_array) {
   intptr_t used_len = growable_array.Length();
   intptr_t capacity_len = growable_array.Capacity();
   Isolate* isolate = Isolate::Current();
-  Array& array = Array::Handle(isolate, growable_array.data());
-  Array& new_array = Array::Handle(isolate, Array::Empty());
+  const Array& array = Array::Handle(isolate, growable_array.data());
+  const Array& new_array = Array::Handle(isolate, Array::Empty());
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
   intptr_t used_size = Array::InstanceSize(used_len);
   NoGCScope no_gc;
 
   // Update the size in the header field and length of the array object.
-  uword tags = 0;
+  uword tags = array.raw_ptr()->tags_;
+  ASSERT(kArray == RawObject::ClassTag::decode(tags));
   tags = RawObject::SizeTag::update(used_size, tags);
   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;
 
     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));
-      raw->ptr()->class_ = isolate->object_store()->array_class();
+      const Class& cls = Class::Handle(isolate->object_store()->array_class());
+      raw->ptr()->class_ = cls.raw();
       tags = 0;
       tags = RawObject::SizeTag::update(leftover_size, tags);
+      tags = RawObject::ClassTag::update(cls.index(), 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));
-      raw->ptr()->class_ = isolate->object_store()->object_class();
+      const Class& cls = Class::Handle(isolate->object_store()->object_class());
+      raw->ptr()->class_ = cls.raw();
       tags = 0;
       tags = RawObject::SizeTag::update(leftover_size, tags);
+      tags = RawObject::ClassTag::update(cls.index(), tags);
       raw->ptr()->tags_ = tags;
     }
   }
   return array.raw();
 }
 
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
                                        Heap::Space space) {
   ObjectStore* object_store = Isolate::Current()->object_store();
@@ skipping 574 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