use bit fields for class state and field type values. This shrinks the snapshot

vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 214 matching lines @@
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
     cls.set_id(Class::kClassId);
-    cls.raw_ptr()->is_const_ = false;
-    cls.raw_ptr()->is_interface_ = false;
+    cls.raw_ptr()->state_bits_ = 0;
     cls.set_is_finalized();
     cls.raw_ptr()->type_arguments_instance_field_offset_ =
         Class::kNoTypeArguments;
     cls.raw_ptr()->num_native_fields_ = 0;
     cls.InitEmptyFields();
     isolate->class_table()->Register(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullCid);
@@ skipping 932 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   result.set_id((FakeObject::kClassId != kInstanceCid &&
                  FakeObject::kClassId != kClosureCid) ?
                 FakeObject::kClassId : kIllegalCid);
-  result.raw_ptr()->is_const_ = false;
-  result.raw_ptr()->is_interface_ = false;
+  result.raw_ptr()->state_bits_ = 0;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
-  result.raw_ptr()->class_state_ = RawClass::kPreFinalized;
+  result.set_is_prefinalized();
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
 // Initialize class fields of type Array with empty array.
@@ skipping 77 matching lines @@
   return closure.raw();
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
-void Class::set_class_state(int8_t state) const {
+void Class::set_class_state(RawClass::ClassState state) const {
   ASSERT((state == RawClass::kAllocated) ||
          (state == RawClass::kPreFinalized) ||
          (state == RawClass::kFinalized));
-  raw_ptr()->class_state_ = state;
+  uword bits = raw_ptr()->state_bits_;
+  raw_ptr()->state_bits_ = StateBits::update(state, bits);
+}
+
+
+void Class::set_state_bits(uint8_t bits) const {
+  raw_ptr()->state_bits_ = bits;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
@@ skipping 253 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_id(index);
-  result.raw_ptr()->is_const_ = false;
-  result.raw_ptr()->is_interface_ = false;
-  result.raw_ptr()->class_state_ = RawClass::kAllocated;
+  result.raw_ptr()->state_bits_ = 0;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(const String& name,
@@ skipping 133 matching lines @@
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
 
 void Class::set_is_interface() const {
-  raw_ptr()->is_interface_ = true;
+  uword bits = raw_ptr()->state_bits_;
+  raw_ptr()->state_bits_ = InterfaceBit::update(true, bits);
 }
 
 
 void Class::set_is_const() const {
-  raw_ptr()->is_const_ = true;
+  uword bits = raw_ptr()->state_bits_;
+  raw_ptr()->state_bits_ = ConstBit::update(true, bits);
 }
 
 
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
-  set_class_state(RawClass::kFinalized);
+  uword bits = raw_ptr()->state_bits_;
+  raw_ptr()->state_bits_ = StateBits::update(RawClass::kFinalized, bits);
 }
 
 
 void Class::set_is_prefinalized() const {
   ASSERT(!is_finalized());
-  set_class_state(RawClass::kPreFinalized);
+  uword bits = raw_ptr()->state_bits_;
+  raw_ptr()->state_bits_ = StateBits::update(RawClass::kPreFinalized, bits);
 }
 
 
 void Class::set_interfaces(const Array& value) const {
   // Verification and resolving of interfaces occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->interfaces_, value.raw());
 }
 
 
@@ skipping 9448 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart