Tree shaker:

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 96 matching lines @@
 
   void WriteClass(Serializer* s, RawClass* cls) {
     Snapshot::Kind kind = s->kind();
     RawObject** from = cls->from();
     RawObject** to = cls->to_snapshot(kind);
     for (RawObject** p = from; p <= to; p++) {
       s->WriteRef(*p);
     }
     intptr_t class_id = cls->ptr()->id_;
     if (class_id == kIllegalCid) {
-      FATAL1("Attempting to serialize class with illegal cid: %s\n",
-             Class::Handle(cls).ToCString());
+      s->UnexpectedObject(cls, "Class with illegal cid");
     }
     s->WriteCid(class_id);
     s->Write<int32_t>(cls->ptr()->instance_size_in_words_);
     s->Write<int32_t>(cls->ptr()->next_field_offset_in_words_);
     s->Write<int32_t>(cls->ptr()->type_arguments_field_offset_in_words_);
     s->Write<uint16_t>(cls->ptr()->num_type_arguments_);
     s->Write<uint16_t>(cls->ptr()->num_own_type_arguments_);
     s->Write<uint16_t>(cls->ptr()->num_native_fields_);
     s->WriteTokenPosition(cls->ptr()->token_pos_);
     s->Write<uint16_t>(cls->ptr()->state_bits_);
@@ skipping 4368 matching lines @@
       heap_(thread->isolate()->heap()),
       zone_(thread->zone()),
       kind_(kind),
       stream_(buffer, alloc, initial_size),
       image_writer_(image_writer),
       clusters_by_cid_(NULL),
       stack_(),
       num_cids_(0),
       num_base_objects_(0),
       num_written_objects_(0),
-      next_ref_index_(1) {
+      next_ref_index_(1)
+#if defined(SNAPSHOT_BACKTRACE)
+      ,
+      current_parent_(Object::null()),
+      parent_pairs_()
+#endif
+{
   num_cids_ = thread->isolate()->class_table()->NumCids();
   clusters_by_cid_ = new SerializationCluster*[num_cids_];
   for (intptr_t i = 0; i < num_cids_; i++) {
     clusters_by_cid_[i] = NULL;
   }
 }
 
 
 Serializer::~Serializer() {
   delete[] clusters_by_cid_;
@@ skipping 124 matching lines @@
     default:
       break;
   }
 
   FATAL1("No cluster defined for cid %" Pd, cid);
   return NULL;
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
 
+void Serializer::Push(RawObject* object) {
+  if (!object->IsHeapObject()) {
+    RawSmi* smi = Smi::RawCast(object);
+    if (smi_ids_.Lookup(smi) == NULL) {
+      SmiObjectIdPair pair;
+      pair.smi_ = smi;
+      pair.id_ = 1;
+      smi_ids_.Insert(pair);
+      stack_.Add(object);
+      num_written_objects_++;
+    }
+    return;
+  }
+
+  if (object->IsCode() && !Snapshot::IncludesCode(kind_)) {
+    return;  // Do not trace, will write null.
+  }
+
+  if (object->IsSendPort()) {
+    // TODO(rmacnak): Do a better job of resetting fields in precompilation
+    // and assert this is unreachable.
+    return;  // Do not trace, will write null.
+  }
+
+  intptr_t id = heap_->GetObjectId(object);
+  if (id == 0) {
+    heap_->SetObjectId(object, 1);
+    ASSERT(heap_->GetObjectId(object) != 0);
+    stack_.Add(object);
+    num_written_objects_++;
+
+#if defined(SNAPSHOT_BACKTRACE)
+    parent_pairs_.Add(&Object::Handle(object));
+    parent_pairs_.Add(&Object::Handle(current_parent_));
+#endif
+  }
+}
+
+
 void Serializer::Trace(RawObject* object) {
   intptr_t cid;
   if (!object->IsHeapObject()) {
     // Smis are merged into the Mint cluster because Smis for the writer might
     // become Mints for the reader and vice versa.
     cid = kMintCid;
   } else {
     cid = object->GetClassId();
   }
 
   SerializationCluster* cluster = clusters_by_cid_[cid];
   if (cluster == NULL) {
     cluster = NewClusterForClass(cid);
     clusters_by_cid_[cid] = cluster;
   }
   ASSERT(cluster != NULL);
+
+#if defined(SNAPSHOT_BACKTRACE)
+  current_parent_ = object;
+#endif
+
   cluster->Trace(this, object);
+
+#if defined(SNAPSHOT_BACKTRACE)
+  current_parent_ = Object::null();
+#endif
 }
 
 
+void Serializer::UnexpectedObject(RawObject* raw_object, const char* message) {
+  Object& object = Object::Handle(raw_object);
+  OS::PrintErr("Unexpected object (%s): %s\n", message, object.ToCString());
+#if defined(SNAPSHOT_BACKTRACE)
+  while (!object.IsNull()) {
+    object = ParentOf(object);
+    OS::PrintErr("referenced by %s\n", object.ToCString());
+  }
+#endif
+  OS::Abort();
+}
+
+
+#if defined(SNAPSHOT_BACKTRACE)
+RawObject* Serializer::ParentOf(const Object& object) {
+  for (intptr_t i = 0; i < parent_pairs_.length(); i += 2) {
+    if (parent_pairs_[i]->raw() == object.raw()) {
+      return parent_pairs_[i + 1]->raw();
+    }
+  }
+  return Object::null();
+}
+#endif  // SNAPSHOT_BACKTRACE
+
+
 void Serializer::WriteVersionAndFeatures() {
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_version), version_len);
 
   const char* expected_features =
       Dart::FeaturesString(Isolate::Current(), kind_);
   ASSERT(expected_features != NULL);
   const intptr_t features_len = strlen(expected_features);
@@ skipping 876 matching lines @@
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart