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

vm/heap_profiler.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/heap_profiler.h"
 
 #include "vm/dart_api_state.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
@@ skipping 499 matching lines @@
   sub.WritePointer(NULL);
 
   intptr_t num_static_fields = 0;
   intptr_t num_instance_fields = 0;
 
   RawArray* raw_array = raw_class->ptr()->fields_;
   if (raw_array != Array::null()) {
     for (intptr_t i = 0; i < Smi::Value(raw_array->ptr()->length_); ++i) {
       RawField* raw_field =
           reinterpret_cast<RawField*>(raw_array->ptr()->data()[i]);
-      if (raw_field->ptr()->is_static_) {
+      if (Field::StaticBit::decode(raw_field->ptr()->kind_bits_)) {
         ++num_static_fields;
       } else {
         ++num_instance_fields;
       }
     }
   }
   // instance size (in bytes)
   // TODO(cshapiro): properly account for variable sized objects
   sub.Write32(raw_class->ptr()->instance_size_);
   // size of constant pool and number of records that follow:
   sub.Write16(0);
   // Number of static fields
   sub.Write16(num_static_fields);
   // Static fields:
   if (raw_array != Array::null()) {
     for (intptr_t i = 0; i < Smi::Value(raw_array->ptr()->length_); ++i) {
       RawField* raw_field =
           reinterpret_cast<RawField*>(raw_array->ptr()->data()[i]);
-      if (raw_field->ptr()->is_static_) {
+      if (Field::StaticBit::decode(raw_field->ptr()->kind_bits_)) {
         ASSERT(raw_field->ptr()->name_ != String::null());
         // static field name string ID
         sub.WritePointer(StringId(raw_field->ptr()->name_));
         // type of static field
         sub.Write8(kObject);
         // value of entry
         sub.WritePointer(ObjectId(raw_field->ptr()->value_));
       }
     }
   }
   // Number of instance fields (not include super class's)
   sub.Write16(num_instance_fields);
   // Instance fields:
   if (raw_array != Array::null()) {
     for (intptr_t i = 0; i < Smi::Value(raw_array->ptr()->length_); ++i) {
       RawField* raw_field =
           reinterpret_cast<RawField*>(raw_array->ptr()->data()[i]);
-      if (!raw_field->ptr()->is_static_) {
+      if (!Field::StaticBit::decode(raw_field->ptr()->kind_bits_)) {
         ASSERT(raw_field->ptr()->name_ != String::null());
         // field name string ID
         sub.WritePointer(StringId(raw_field->ptr()->name_));
         // type of field
         sub.Write8(kObject);
       }
     }
   }
 }
 
@@ skipping 18 matching lines @@
   intptr_t num_instance_fields = 0;
   for (const RawClass* cls = GetClass(raw_obj);
        cls != Class::null();
        cls = GetSuperClass(cls)) {
     RawArray* raw_array = cls->ptr()->fields_;
     if (raw_array != Array::null()) {
       intptr_t length = Smi::Value(raw_array->ptr()->length_);
       for (intptr_t i = 0; i < length; ++i) {
         RawField* raw_field =
             reinterpret_cast<RawField*>(raw_array->ptr()->data()[i]);
-        if (!raw_field->ptr()->is_static_) {
+        if (!Field::StaticBit::decode(raw_field->ptr()->kind_bits_)) {
           ++num_instance_fields;
         }
       }
     }
   }
   sub.Write32(num_instance_fields * kWordSize);
   // instance field values (this class, followed by super class, etc)
   for (const RawClass* cls = GetClass(raw_obj);
        cls != Class::null();
        cls = GetSuperClass(cls)) {
     RawArray* raw_array = cls->ptr()->fields_;
     if (raw_array != Array::null()) {
       intptr_t length = Smi::Value(raw_array->ptr()->length_);
       uint8_t* base = reinterpret_cast<uint8_t*>(raw_obj->ptr());
       for (intptr_t i = 0; i < length; ++i) {
         RawField* raw_field =
             reinterpret_cast<RawField*>(raw_array->ptr()->data()[i]);
-        if (!raw_field->ptr()->is_static_) {
+        if (!Field::StaticBit::decode(raw_field->ptr()->kind_bits_)) {
           intptr_t offset =
               Smi::Value(reinterpret_cast<RawSmi*>(raw_field->ptr()->value_));
           RawObject* ptr = *reinterpret_cast<RawObject**>(base + offset);
           sub.WritePointer(ObjectId(ptr));
         }
       }
     }
   }
 }
 
@@ skipping 90 matching lines @@
   RawObject* raw_obj = handle->raw();
   visitor_->VisitPointer(&raw_obj);
 }
 
 
 void HeapProfilerObjectVisitor::VisitObject(RawObject* raw_obj) {
   profiler_->WriteObject(raw_obj);
 }
 
 }  // namespace dart