Reclaim the CreatedFromSnapshot bit and use it to indicate VM Heap object

runtime/vm/raw_object.h

 // 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.
 
 #ifndef VM_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 218 matching lines @@
 // class_ field not all raw objects are allocated in the heap and thus cannot
 // be dereferenced (e.g. RawSmi).
 class RawObject {
  public:
   // The tags field which is a part of the object header uses the following
   // bit fields for storing tags.
   enum TagBits {
     kWatchedBit = 0,
     kMarkBit = 1,
     kCanonicalBit = 2,
-    kFromSnapshotBit = 3,
+    kVMHeapObjectBit = 3,
     kRememberedBit = 4,
 #if defined(ARCH_IS_32_BIT)
     kReservedTagPos = 5,  // kReservedBit{100K,1M,10M}
     kReservedTagSize = 3,
     kSizeTagPos = kReservedTagPos + kReservedTagSize,  // = 8
     kSizeTagSize = 8,
     kClassIdTagPos = kSizeTagPos + kSizeTagSize,  // = 16
     kClassIdTagSize = 16,
 #elif defined(ARCH_IS_64_BIT)
     kReservedTagPos = 5,  // kReservedBit{100K,1M,10M}
@@ skipping 58 matching lines @@
     ASSERT(IsHeapObject());
     uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectAlignmentOffset) == kNewObjectAlignmentOffset;
   }
   // Assumes this is a heap object.
   bool IsOldObject() const {
     ASSERT(IsHeapObject());
     uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectAlignmentOffset) == kOldObjectAlignmentOffset;
   }
-  // Assumes this is a heap object.
-  bool IsVMHeapObject() const;
 
   // Like !IsHeapObject() || IsOldObject(), but compiles to a single branch.
   bool IsSmiOrOldObject() const {
     ASSERT(IsWellFormed());
     COMPILE_ASSERT(kHeapObjectTag == 1);
     COMPILE_ASSERT(kNewObjectAlignmentOffset == kWordSize);
     static const uword kNewObjectBits =
         (kNewObjectAlignmentOffset | kHeapObjectTag);
     const uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectBits) != kNewObjectBits;
@@ skipping 35 matching lines @@
   // Support for object tags.
   bool IsCanonical() const {
     return CanonicalObjectTag::decode(ptr()->tags_);
   }
   void SetCanonical() {
     UpdateTagBit<CanonicalObjectTag>(true);
   }
   void ClearCanonical() {
     UpdateTagBit<CanonicalObjectTag>(false);
   }
-  bool IsCreatedFromSnapshot() const {
-    return CreatedFromSnapshotTag::decode(ptr()->tags_);
+  bool IsVMHeapObject() const {
+    return VMHeapObjectTag::decode(ptr()->tags_);
   }
-  void SetCreatedFromSnapshot() {
-    UpdateTagBit<CreatedFromSnapshotTag>(true);
+  void SetVMHeapObject() {
+    UpdateTagBit<VMHeapObjectTag>(true);
   }
 
   // Support for GC remembered bit.
   bool IsRemembered() const {
     return RememberedBit::decode(ptr()->tags_);
   }
   void SetRememberedBit() {
     ASSERT(!IsRemembered());
     UpdateTagBit<RememberedBit>(true);
   }
@@ skipping 48 matching lines @@
   static RawObject* FromAddr(uword addr) {
     // We expect the untagged address here.
     ASSERT((addr & kSmiTagMask) != kHeapObjectTag);
     return reinterpret_cast<RawObject*>(addr + kHeapObjectTag);
   }
 
   static uword ToAddr(const RawObject* raw_obj) {
     return reinterpret_cast<uword>(raw_obj->ptr());
   }
 
-  static bool IsCreatedFromSnapshot(intptr_t value) {
-    return CreatedFromSnapshotTag::decode(value);
+  static bool IsVMHeapObject(intptr_t value) {
+    return VMHeapObjectTag::decode(value);
   }
 
   static bool IsCanonical(intptr_t value) {
     return CanonicalObjectTag::decode(value);
   }
 
   // Class Id predicates.
   static bool IsErrorClassId(intptr_t index);
   static bool IsNumberClassId(intptr_t index);
   static bool IsIntegerClassId(intptr_t index);
@@ skipping 15 matching lines @@
   uword tags_;  // Various object tags (bits).
 
   class WatchedBit : public BitField<bool, kWatchedBit, 1> {};
 
   class MarkBit : public BitField<bool, kMarkBit, 1> {};
 
   class RememberedBit : public BitField<bool, kRememberedBit, 1> {};
 
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
 
-  class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
+  class VMHeapObjectTag : public BitField<bool, kVMHeapObjectBit, 1> {};
 
   class ReservedBits : public
       BitField<intptr_t, kReservedTagPos, kReservedTagSize> {};  // NOLINT
 
   // TODO(koda): After handling tags_, return const*, like Object::raw_ptr().
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
@@ skipping 447 matching lines @@
 
   Dart_NativeEntryResolver native_entry_resolver_;  // Resolves natives.
   Dart_NativeEntrySymbol native_entry_symbol_resolver_;
   classid_t index_;             // Library id number.
   classid_t num_anonymous_;     // Number of entries in anonymous_classes_.
   uint16_t num_imports_;        // Number of entries in imports_.
   int8_t load_state_;           // Of type LibraryState.
   bool corelib_imported_;
   bool is_dart_scheme_;
   bool debuggable_;             // True if debugger can stop in library.
+  bool is_in_fullsnapshot_;     // True if library is in a full snapshot.
 
+  friend class Class;
   friend class Isolate;
 };
 
 
 class RawNamespace : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Namespace);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_);
   }
@@ skipping 1230 matching lines @@
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_