Add a flags field to RawObject so that we can tag objects with certain

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 133 matching lines @@
     kInvalidIndex = -1,
   };
 
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) { SetRaw(value); }
 
   inline RawClass* clazz() const;
   static intptr_t class_offset() { return OFFSET_OF(RawObject, class_); }
+  static intptr_t tags_offset() { return OFFSET_OF(RawObject, tags_); }
 
   // Class testers.
 #define DEFINE_CLASS_TESTER(clazz)                                             \
   virtual bool Is##clazz() const { return false; }
 CLASS_LIST_NO_OBJECT(DEFINE_CLASS_TESTER);
 #undef DEFINE_CLASS_TESTER
 
   bool IsNull() const { return raw_ == null_; }
 
   virtual const char* ToCString() const {
@@ skipping 865 matching lines @@
     return OFFSET_OF(RawTypeArguments, length_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypeArguments) == OFFSET_OF(RawTypeArguments, types_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     // Ensure that the types_ is not adding to the object length.
-    ASSERT(sizeof(RawTypeArguments) == 3 * kWordSize);
+    ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (2 * kWordSize)));
     return RoundedAllocationSize(sizeof(RawTypeArguments) + (len * kWordSize));
   }
 
   static RawTypeArguments* New(intptr_t len);
 
  private:
   bool is_canonical() const;
   void set_is_canonical(bool value) const;
 
   // Make sure that the array size cannot wrap around.
@@ skipping 1885 matching lines @@
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawArray, type_arguments_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawArray) == OFFSET_OF_RETURNED_VALUE(RawArray, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
-    ASSERT(sizeof(RawArray) == 3 * kWordSize);
+    // Ensure that variable length data is not adding to the object length.
+    ASSERT(sizeof(RawArray) == (sizeof(RawObject) + (2 * kWordSize)));
     return RoundedAllocationSize(sizeof(RawArray) + (len * kWordSize));
   }
 
   // Make the array immutable to Dart code by switching the class pointer
   // to ImmutableArray.
   void MakeImmutable() const;
 
   static RawArray* New(intptr_t len, Heap::Space space = Heap::kNew) {
     return New(len, false, space);
   }
@@ skipping 316 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_