More compact snapshots.

src/vm/program.cc

 // Copyright (c) 2014, the Dartino 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.md file.
 
 #include "src/vm/program.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/shared/assert.h"
@@ skipping 108 matching lines @@
 
   AddToProcessList(process);
   return process;
 }
 
 Process* Program::ProcessSpawnForMain(List<List<uint8>> arguments) {
   if (Flags::print_program_statistics) {
     PrintStatistics();
   }
 
+  VerifyObjectPlacements();
+
   Process* process = SpawnProcess(NULL);
 
   // TODO(erikcorry): This is not valid for multiple programs, where the
   // process creation could fail.
   ASSERT(!process->AllocationFailed());
 
   process->set_arguments(arguments);
 
   Stack* stack = process->stack();
 
@@ skipping 206 matching lines @@
 
 void Program::FinishProgramGC() {
   // Uncook process
   UncookAndUnchainStacks();
 
   FinishProgramGCVisitor visitor;
   VisitProcesses(&visitor);
 
   if (debug_info_ != NULL) debug_info_->UpdateBreakpoints();
 
+  VerifyObjectPlacements();
+
   if (Flags::validate_heaps) ValidateHeapsAreConsistent();
 }
 
 uword Program::OffsetOf(HeapObject* object) {
   ASSERT(is_optimized());
   return heap()->space()->OffsetOf(object);
 }
 
 HeapObject *Program::ObjectAtOffset(uword offset) {
   ASSERT(was_loaded_from_snapshot());
@@ skipping 433 matching lines @@
   // allocations, instead allocate new chunks.
   NoAllocationFailureScope scope(heap_.space());
 
   // Create null as the first object other allocated objects can use
   // null_object for initial values.
   InstanceFormat null_format =
       InstanceFormat::instance_format(0, InstanceFormat::NULL_MARKER);
   null_object_ =
       reinterpret_cast<Instance*>(heap()->Allocate(null_format.fixed_size()));
 
+  InstanceFormat false_format =
+      InstanceFormat::instance_format(0, InstanceFormat::FALSE_MARKER);
+  uword false_address =
+      HeapObject::cast(heap()->Allocate(false_format.fixed_size()))->address();
+  InstanceFormat true_format =
+      InstanceFormat::instance_format(0, InstanceFormat::TRUE_MARKER);
+  uword true_address =
+      HeapObject::cast(heap()->Allocate(true_format.fixed_size()))->address();
+
   meta_class_ = Class::cast(heap()->CreateMetaClass());
 
   {
     InstanceFormat format = InstanceFormat::array_format();
     array_class_ =
         Class::cast(heap()->CreateClass(format, meta_class_, null_object_));
   }
 
   empty_array_ = Array::cast(CreateArray(0));
 
@@ skipping 166 matching lines @@
   }
 
   {  // Create the bool class.
     InstanceFormat format = InstanceFormat::instance_format(0);
     bool_class_ =
         Class::cast(heap()->CreateClass(format, meta_class_, null_object_));
     bool_class_->set_super_class(object_class_);
   }
 
   {  // Create False class and the false object.
-    InstanceFormat format =
-        InstanceFormat::instance_format(0, InstanceFormat::FALSE_MARKER);
-    Class* false_class =
-        Class::cast(heap()->CreateClass(format, meta_class_, null_object_));
+    Class* false_class = Class::cast(
+        heap()->CreateClass(false_format, meta_class_, null_object_));
     false_class->set_super_class(bool_class_);
     false_class->set_methods(empty_array_);
     false_object_ = Instance::cast(
-        heap()->CreateInstance(false_class, null_object(), true));
+        heap()->CreateBooleanObject(false_address, false_class, null_object()));
   }
 
   {  // Create True class and the true object.
-    InstanceFormat format =
-        InstanceFormat::instance_format(0, InstanceFormat::TRUE_MARKER);
-    Class* true_class =
-        Class::cast(heap()->CreateClass(format, meta_class_, null_object_));
+    Class* true_class = Class::cast(
+        heap()->CreateClass(true_format, meta_class_, null_object_));
     true_class->set_super_class(bool_class_);
     true_class->set_methods(empty_array_);
-    true_object_ =
-        Instance::cast(heap()->CreateInstance(true_class, null_object(), true));
+    true_object_ = Instance::cast(
+        heap()->CreateBooleanObject(true_address, true_class, null_object()));
   }
 
   {  // Create stack overflow error object.
     InstanceFormat format = InstanceFormat::instance_format(0);
     stack_overflow_error_class_ =
         Class::cast(heap()->CreateClass(format, meta_class_, null_object_));
     stack_overflow_error_ = Instance::cast(heap()->CreateInstance(
         stack_overflow_error_class_, null_object(), true));
   }
 
   // Create the retry after gc failure object payload.
   raw_retry_after_gc_ = OneByteString::cast(
       CreateStringFromAscii(StringFromCharZ("Retry after GC.")));
 
   // Create the failure object payloads. These need to be kept in sync with the
   // constants in lib/system/system.dart.
   raw_wrong_argument_type_ = OneByteString::cast(
       CreateStringFromAscii(StringFromCharZ("Wrong argument type.")));
 
   raw_index_out_of_bounds_ = OneByteString::cast(
       CreateStringFromAscii(StringFromCharZ("Index out of bounds.")));
 
   raw_illegal_state_ = OneByteString::cast(
       CreateStringFromAscii(StringFromCharZ("Illegal state.")));
 
   native_failure_result_ = null_object_;
+  VerifyObjectPlacements();
+}
+
+void Program::VerifyObjectPlacements() {
+  uword n = reinterpret_cast<uword>(null_object_);
+  uword f = reinterpret_cast<uword>(false_object_);
+  uword t = reinterpret_cast<uword>(true_object_);
+  ASSERT(f - n == 2 * kWordSize);
+  ASSERT(t - f == 2 * kWordSize);
 }
 
 void Program::IterateRoots(PointerVisitor* visitor) {
+  VerifyObjectPlacements();
+
   IterateRootsIgnoringSession(visitor);
   if (debug_info_ != NULL) {
     debug_info_->VisitProgramPointers(visitor);
   }
   if (session_ != NULL) {
     session_->IteratePointers(visitor);
   }
 }
 
 void Program::IterateRootsIgnoringSession(PointerVisitor* visitor) {
@@ skipping 270 matching lines @@
   if (reinterpret_cast<Type*>(address) == field_name##_) { \
     fprintf(stderr, "0x%zx is " #field_name "\n",          \
             static_cast<size_t>(address));                 \
   }
   ROOTS_DO(CHECK_FOR_ROOT)
 #undef CHECK_FOR_ROOT
 }
 #endif
 
 }  // namespace dartino