Changes to set up the object tag bits

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 79 matching lines @@
     }                                                                          \
   }                                                                            \
   /* Disallow allocation, copy constructors and override super assignment. */  \
   void* operator new(size_t size);                                             \
   object(const object& value);                                                 \
   void operator=(Raw##super* value);                                           \
   void operator=(const object& value);                                         \
   void operator=(const super& value);                                          \
 
 #define SNAPSHOT_READER_SUPPORT(object)                                        \
-  static Raw##object* ReadFrom(                                                \
-      SnapshotReader* reader, intptr_t object_id, Snapshot::Kind);             \
+  static Raw##object* ReadFrom(SnapshotReader* reader,                         \
+                               intptr_t object_id,                             \
+                               intptr_t tags,                                  \
+                               Snapshot::Kind);                                \
   friend class SnapshotReader;                                                 \
 
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
 
@@ skipping 30 matching lines @@
     kApiErrorClass,
     kMaxId,
     kInvalidIndex = -1,
   };
 
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) { SetRaw(value); }
 
+  void set_tags(intptr_t tags) {
+    ASSERT(!IsNull());
+    raw()->ptr()->tags_ = tags;
+  }
+  void SetCreatedFromSnapshot() const {
+    ASSERT(!IsNull());
+    raw()->SetCreatedFromSnapshot();
+  }
+  bool IsCanonical() const {
+    ASSERT(!IsNull());
+    return raw()->IsCanonical();
+  }
+  void SetCanonical() const {
+    ASSERT(!IsNull());
+    raw()->SetCanonical();
+  }
+
   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
 
@@ skipping 868 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) == (sizeof(RawObject) + (2 * kWordSize)));
+    ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (1 * 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.
   static const intptr_t kMaxTypes = 512 * 1024 * 1024;
   RawAbstractType** TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value);
 
   HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
   friend class Class;
 };
 
 
@@ skipping 1409 matching lines @@
   bool Equals(const uint32_t* characters, intptr_t len) const;
 
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
 
   virtual RawInstance* Canonicalize() const;
 
-  bool IsSymbol() const;
+  bool IsSymbol() const { return raw()->IsCanonical(); }
 
   virtual bool IsExternal() const { return false; }
   virtual void* GetPeer() const {
     UNREACHABLE();
     return NULL;
   }
 
   static RawString* New(const char* str, Heap::Space space = Heap::kNew);
   static RawString* New(const uint8_t* characters,
                         intptr_t len,
@@ skipping 85 matching lines @@
 
   void SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->hash_ = Smi::New(value);
   }
 
   template<typename HandleType, typename ElementType>
   static RawString* ReadFromImpl(SnapshotReader* reader,
                                  intptr_t object_id,
+                                 intptr_t tags,
                                  Snapshot::Kind kind);
 
   HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 };
 
 
 class OneByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
@@ skipping 677 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_