- Add a size field to the header.

vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/globals.h"
 #include "vm/snapshot.h"
@@ skipping 73 matching lines @@
   kFreeListElement,
   kNumOfObjectKinds = kFreeListElement
 };
 
 enum ObjectAlignment {
   // Alignment offsets are used to determine object age.
   kNewObjectAlignmentOffset = kWordSize,
   kOldObjectAlignmentOffset = 0,
   // Object sizes are aligned to kObjectAlignment.
   kObjectAlignment = 2 * kWordSize,
+  kObjectAlignmentLog2 = kWordSizeLog2 + 1,
   kObjectAlignmentMask = kObjectAlignment - 1,
 };
 
 enum {
   kSmiTag = 0,
   kHeapObjectTag = 1,
   kSmiTagSize = 1,
   kSmiTagMask = 1,
   kSmiTagShift = 1,
 };
@@ skipping 22 matching lines @@
       ASSERT(IsHeapObject());                                                  \
       return reinterpret_cast<Raw##object*>(                                   \
           reinterpret_cast<uword>(this) - kHeapObjectTag);                     \
     }                                                                          \
     SNAPSHOT_WRITER_SUPPORT()                                                  \
 
 
 // RawObject is the base class of all raw objects, even though it carries the
 // class_ field not all raw objects are allocated in the heap and thus cannot
 // be dereferenced (e.g. RawSmi).
-//
-// The tags field which is a part of the object header uses the following
-// bit fields for storing tags.
-//
-// bit 0 - SmiTag
-// bit 1 - Mark bit.
-// bit 2 - Canonical object.
-// bit 3 - Created from a full snapshot.
-//
 class RawObject {
  public:
+  // The tags field which is a part of the object header uses the following
+  // bit fields for storing tags.
+  enum TagBits {
+    kFreeBit = 0,
+    kMarkBit = 1,
+    kCanonicalBit = 2,
+    kFromSnapshotBit = 3,
+    kReservedBit10K = 4,
+    kReservedBit100K = 5,
+    kReservedBit1M = 6,
+    kReservedBit10M = 7,
+    kSizeTagBit = 8,
+    kSizeTagSize = 8,
+  };
+
+  // Encodes the object size in the tag in units of object alignment.
+  class SizeTag {
+   public:
+    static const intptr_t kMaxSizeTag =
+        ((1 << RawObject::kSizeTagSize) - 1) << kObjectAlignmentLog2;
+
+    static uword encode(intptr_t size) {
+      return SizeBits::encode(SizeToTagValue(size));
+    }
+
+    static intptr_t decode(uword tag) {
+      return TagValueToSize(SizeBits::decode(tag));
+    }
+
+    static uword update(intptr_t size, uword tag) {
+      return SizeBits::update(SizeToTagValue(size), tag);
+    }
+
+  private:
+    // The actual unscaled bit field used within the tag field.
+    class SizeBits : public BitField<intptr_t, kSizeTagBit, kSizeTagSize> {};
+
+    static intptr_t SizeToTagValue(intptr_t size) {
+      ASSERT(Utils::IsAligned(size, kObjectAlignment));
+      return  (size > kMaxSizeTag) ? 0 : (size >> kObjectAlignmentLog2);
+    }
+    static intptr_t TagValueToSize(intptr_t value) {
+      return value << kObjectAlignmentLog2;
+    }
+  };
+
   bool IsHeapObject() const {
     uword value = reinterpret_cast<uword>(this);
     return (value & kSmiTagMask) == kHeapObjectTag;
   }
 
   bool IsNewObject() const {
     uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectAlignmentOffset) == kNewObjectAlignmentOffset;
   }
   bool IsOldObject() const {
     uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectAlignmentOffset) == kOldObjectAlignmentOffset;
   }
 
   // Support for GC marking bit.
   bool IsMarked() const {
     return MarkBit::decode(ptr()->tags_);
   }
   void SetMarkBit() {
     ASSERT(!IsMarked());
-    intptr_t tags = ptr()->tags_;
+    uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(true, tags);
   }
   void ClearMarkBit() {
     ASSERT(IsMarked());
-    intptr_t tags = ptr()->tags_;
+    uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(false, tags);
   }
 
   // Support for object tags.
   bool IsCanonical() const {
     return CanonicalObjectTag::decode(ptr()->tags_);
   }
   void SetCanonical() {
-    intptr_t tags = ptr()->tags_;
+    uword tags = ptr()->tags_;
     ptr()->tags_ = CanonicalObjectTag::update(true, tags);
   }
-  bool IsCreatedFromSnapshot() {
+  bool IsCreatedFromSnapshot() const {
     return CreatedFromSnapshotTag::decode(ptr()->tags_);
   }
   void SetCreatedFromSnapshot() {
-    intptr_t tags = ptr()->tags_;
+    uword tags = ptr()->tags_;
     ptr()->tags_ = CreatedFromSnapshotTag::update(true, tags);
   }
 
+  intptr_t Size() const {
+    uword tags = ptr()->tags_;
+    intptr_t result = SizeTag::decode(tags);
+    if ((result != 0) && !FreeBit::decode(tags)) {
+      ASSERT(result == SizeFromClass());
+      return result;
+    }
+    result = SizeFromClass();
+    ASSERT((result > SizeTag::kMaxSizeTag) || FreeBit::decode(tags));
+    return result;
+  }
+
   void Validate() const;
-  intptr_t Size() const;
   intptr_t VisitPointers(ObjectPointerVisitor* visitor);
 
   static RawObject* FromAddr(uword addr) {
     // We expect the untagged address here.
     ASSERT((addr & kSmiTagMask) != kHeapObjectTag);
     return reinterpret_cast<RawObject*>(addr + kHeapObjectTag);
   }
 
   static uword ToAddr(RawObject* raw_obj) {
     return reinterpret_cast<uword>(raw_obj->ptr());
   }
 
   static bool IsCreatedFromSnapshot(intptr_t value) {
     return CreatedFromSnapshotTag::decode(value);
   }
 
   static bool IsCanonical(intptr_t value) {
     return CanonicalObjectTag::decode(value);
   }
 
  protected:
   RawClass* class_;
-  intptr_t tags_;  // Various object tags (bits).
+  uword tags_;  // Various object tags (bits).
 
  private:
-  enum {
-    kMarkBit = 1,
-    kCanonicalBit = 2,
-    kFromSnapshotBit = 3,
-  };
+  class FreeBit : public BitField<bool, kFreeBit, 1> {};
 
   class MarkBit : public BitField<bool, kMarkBit, 1> {};
 
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
 
   class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
 
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
+  intptr_t SizeFromClass() const;
+
   friend class Object;
   friend class Array;
   friend class SnapshotWriter;
   friend class SnapshotReader;
   friend class MarkingVisitor;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(RawObject);
 };
 
@@ skipping 667 matching lines @@
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_