Changes to set up the object tag bits

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 114 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:
   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;
@@ skipping 14 matching lines @@
     ASSERT(!IsMarked());
     uword header_bits = reinterpret_cast<uword>(ptr()->class_);
     ptr()->class_ = reinterpret_cast<RawClass*>(header_bits | kMarked);
   }
   void ClearMarkBit() {
     ASSERT(IsMarked());
     uword header_bits = reinterpret_cast<uword>(ptr()->class_);
     ptr()->class_ = reinterpret_cast<RawClass*>(header_bits ^ kMarked);
   }
 
+  // Support for object tags.
+  bool IsCanonical() const {
+    return CanonicalObjectTag::decode(ptr()->tags_);
+  }
+  void SetCanonical() {
+    intptr_t tags = ptr()->tags_;
+    ptr()->tags_ = CanonicalObjectTag::update(true, tags);
+  }
+  bool IsCreatedFromSnapshot() {
+    return CreatedFromSnapshotTag::decode(ptr()->tags_);
+  }
+  void SetCreatedFromSnapshot() {
+    intptr_t tags = ptr()->tags_;
+    ptr()->tags_ = CreatedFromSnapshotTag::update(true, tags);
+  }
+
   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).
 
  private:
   enum {
     kMarkingMask = 3,
     kNotMarked = 1,  // Tagged pointer.
     kMarked = 3,  // Tagged pointer and forwarding bit set.
   };
 
+  class CanonicalObjectTag : public BitField<bool, 2, 1> {
+  };
+
+  class CreatedFromSnapshotTag : public BitField<bool, 3, 1> {
+  };
+
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
-  intptr_t tags_;  // Various object tags (bits).
-
   friend class Object;
   friend class Array;
   friend class SnapshotWriter;
   friend class SnapshotReader;
   friend class MarkingVisitor;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(RawObject);
 };
 
@@ skipping 125 matching lines @@
 };
 
 
 class RawTypeArguments : public RawAbstractTypeArguments {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->length_);
   }
-  bool is_canonical_;
   RawSmi* length_;
 
   // Variable length data follows here.
   RawAbstractType* types_[0];
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types_[length - 1]);
   }
 };
 
 
@@ skipping 505 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_