Resubmit reverted r17962, but, for now, only report error about unfinalized

runtime/vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, error_on_malformed_type);
+
+
 #define NEW_OBJECT(type)                                                       \
   ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
   ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
 
 #define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
   ((kind == Snapshot::kFull) ?                                                 \
   reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
 
@@ skipping 81 matching lines @@
 
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer);
     visitor.VisitPointers(from(), to());
   } else {
     writer->WriteClassId(this);
   }
 }
 
 
+static const char* RawOneByteStringToCString(RawOneByteString* str) {
+  const char* start = reinterpret_cast<char*>(str) - kHeapObjectTag +
+      OneByteString::data_offset();
+  const int len = Smi::Value(*reinterpret_cast<RawSmi**>(
+      reinterpret_cast<uword>(str) - kHeapObjectTag + String::length_offset()));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+  memmove(chars, start, len);
+  chars[len] = '\0';
+  return chars;
+}
+
+
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
+  // Only resolved and finalized types should be written to a snapshot.
+  // TODO(regis): Replace this code by an UNREACHABLE().
+
   // Allocate parameterized type object.
   UnresolvedClass& unresolved_class = UnresolvedClass::ZoneHandle(
       reader->isolate(), NEW_OBJECT(UnresolvedClass));
   reader->AddBackRef(object_id, &unresolved_class, kIsDeserialized);
 
   // Set the object tags.
   unresolved_class.set_tags(tags);
 
   // Set all non object fields.
   unresolved_class.set_token_pos(reader->ReadIntptrValue());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (unresolved_class.raw()->to() -
                        unresolved_class.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     unresolved_class.StorePointer((unresolved_class.raw()->from() + i),
                                   reader->ReadObjectRef());
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
+  // Only resolved and finalized types should be written to a snapshot.
+  // TODO(regis): Replace this code by an UNREACHABLE().
+  if (FLAG_error_on_malformed_type) {
+    // Print the name of the unresolved class, as well as the token location
+    // from where it is referred to, making sure not to allocate any handles.
+    // Unfortunately, we cannot print the script name.
+    OS::Print("Snapshotting unresolved class '%s' at token pos %"Pd"\n",
+              RawOneByteStringToCString(
+                  reinterpret_cast<RawOneByteString*>(ptr()->ident_)),
+              ptr()->token_pos_);
+    UNREACHABLE();
+  }
+
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kUnresolvedClassCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
 
@@ skipping 52 matching lines @@
 
   return type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
+  // Only resolved and finalized types should be written to a snapshot.
+  // TODO(regis): Replace the test below by an ASSERT().
+  if (FLAG_error_on_malformed_type &&
+      (ptr()->type_state_ != RawType::kFinalizedInstantiated) &&
+      (ptr()->type_state_ != RawType::kFinalizedUninstantiated)) {
+    // Print the name of the class of the unfinalized type, as well as the
+    // token location from where it is referred to, making sure not
+    // to allocate any handles. Unfortunately, we cannot print the script name.
+    const intptr_t cid = ClassIdTag::decode(*reinterpret_cast<uword*>(
+        reinterpret_cast<uword>(ptr()->type_class_) - kHeapObjectTag +
+            Object::tags_offset()));
+    if (cid == kUnresolvedClassCid) {
+      OS::Print("Snapshotting unresolved type '%s' at token pos %"Pd"\n",
+                RawOneByteStringToCString(
+                    reinterpret_cast<RawOneByteString*>(
+                        reinterpret_cast<RawUnresolvedClass*>(
+                            ptr()->type_class_)->ptr()->ident_)),
+                ptr()->token_pos_);
+    } else {
+      // Assume cid == kClassId, but it can also be kIllegalCid.
+      OS::Print("Snapshotting unfinalized type '%s' at token pos %"Pd"\n",
+                RawOneByteStringToCString(
+                    reinterpret_cast<RawOneByteString*>(
+                        reinterpret_cast<RawClass*>(
+                            ptr()->type_class_)->ptr()->name_)),
+                ptr()->token_pos_);
+    }
+    UNREACHABLE();
+  }
+
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kTypeCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(
-          reader->isolate(), NEW_OBJECT(TypeParameter));
+      reader->isolate(), NEW_OBJECT(TypeParameter));
   reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
   type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_token_pos(reader->ReadIntptrValue());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type_parameter.raw()->to() -
                        type_parameter.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     type_parameter.StorePointer((type_parameter.raw()->from() + i),
                                 reader->ReadObjectRef());
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
+  // Only finalized type parameters should be written to a snapshot.
+  // TODO(regis): Replace the test below by an ASSERT().
+  if (FLAG_error_on_malformed_type &&
+      (ptr()->type_state_ != RawTypeParameter::kFinalizedUninstantiated)) {
+    // Print the name of the unfinalized type parameter, the name of the class
+    // it parameterizes, as well as the token location from where it is referred
+    // to, making sure not to allocate any handles. Unfortunately, we cannot
+    // print the script name.
+    OS::Print("Snapshotting unfinalized type parameter '%s' of class '%s' at "
+              "token pos %"Pd"\n",
+              RawOneByteStringToCString(
+                  reinterpret_cast<RawOneByteString*>(ptr()->name_)),
+              RawOneByteStringToCString(
+                  reinterpret_cast<RawOneByteString*>(
+                      reinterpret_cast<RawClass*>(
+                          ptr()->parameterized_class_)->ptr()->name_)),
+              ptr()->token_pos_);
+    UNREACHABLE();
+  }
+
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kTypeParameterCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->index_);
   writer->WriteIntptrValue(ptr()->token_pos_);
@@ skipping 1957 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart