Throw illegal argument exception when

vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 777 matching lines @@
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteObjectRef(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
-  NoGCScope no_gc;
+  NoGCDuringSnapshotWriteScope no_gc;
   RawClass* cls = class_table_->At(raw->GetClassId());
   intptr_t class_id = cls->ptr()->id_;
   ASSERT(class_id == raw->GetClassId());
   if (class_id >= kNumPredefinedCids) {
-    ASSERT(!Class::IsSignatureClass(cls));
+    if (Class::IsSignatureClass(cls)) {
+      // We do not allow closure objects in an isolate message.
+      ThrowIllegalArgException(no_gc,
+                               "Illegal argument in isolate message"
+                               " : (object is a closure)");
+    }
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
@@ skipping 92 matching lines @@
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     return forward_list_[id - kMaxPredefinedObjectIds]->tags();
   } else {
     return tags;
   }
 }
 
 
 intptr_t SnapshotWriter::MarkObject(RawObject* raw, SerializeState state) {
-  NoGCScope no_gc;
+  NoGCDuringSnapshotWriteScope no_gc;
   intptr_t object_id = forward_list_.length() + kMaxPredefinedObjectIds;
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   raw->ptr()->tags_ = value;
   ForwardObjectNode* node = new ForwardObjectNode(raw, tags, state);
   ASSERT(node != NULL);
   forward_list_.Add(node);
   return object_id;
 }
 
 
 void SnapshotWriter::UnmarkAll() {
-  NoGCScope no_gc;
+  NoGCDuringSnapshotWriteScope no_gc;
   for (intptr_t i = 0; i < forward_list_.length(); i++) {
     RawObject* raw = forward_list_[i]->raw();
     raw->ptr()->tags_ = forward_list_[i]->tags();  // Restore original tags.
   }
 }
 
 
 bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
   // Check if object can be written in one of the following ways:
   // - Smi: the Smi value is written as is (last bit is not tagged).
   // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
   // - Object that has already been written: (negative id in stream | 0x3)
 
-  NoGCScope no_gc;
+  NoGCDuringSnapshotWriteScope no_gc;
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
     Write<int64_t>(reinterpret_cast<intptr_t>(rawobj));
     return true;
   }
 
   // Check if object has already been serialized, in that case just write
   // the object id out.
   uword tags = rawobj->ptr()->tags_;
@@ skipping 58 matching lines @@
   WriteInlinedObject(raw);
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
-  NoGCScope no_gc;
+  NoGCDuringSnapshotWriteScope no_gc;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
   tags = forward_list_[object_id - kMaxPredefinedObjectIds]->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   intptr_t class_id = cls->ptr()->id_;
 
   if (class_id >= kNumPredefinedCids) {
-    ASSERT(!Class::IsSignatureClass(cls));
+    if (Class::IsSignatureClass(cls)) {
+      // We do not allow closure objects in an isolate message.
+      ThrowIllegalArgException(no_gc,
+                               "Illegal argument in isolate message"
+                               " : (object is a closure)");
+    }
+    if (cls->ptr()->num_native_fields_ != 0) {
+      // We do not allow objects with native fields in an isolate message.
+      ThrowIllegalArgException(no_gc,
+                               "Illegal argument in isolate message"
+                               " : (object extends NativeWrapper)");
+    }
     // Object is regular dart instance.
-    // TODO(5411462): figure out what we need to do if an object with native
-    // fields is serialized (throw exception or serialize a null object).
-    ASSERT(cls->ptr()->num_native_fields_ == 0);
     intptr_t instance_size = cls->ptr()->instance_size_;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
     WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
     // Write out the tags.
@@ skipping 92 matching lines @@
   // Write out the type arguments.
   WriteObjectImpl(type_arguments);
 
   // Write out the individual object ids.
   for (intptr_t i = 0; i < len; i++) {
     WriteObjectRef(data[i]);
   }
 }
 
 
+void SnapshotWriter::ThrowIllegalArgException(
+    const NoGCDuringSnapshotWriteScope& no_gc, const char* msg) {
+  UnmarkAll();
+  no_gc.Reset();
+  const String& msg_obj = String::Handle(String::New(msg));
+  GrowableArray<const Object*> args(1);
+  args.Add(&msg_obj);
+  Exceptions::ThrowByType(Exceptions::kIllegalArgument, args);
+  UNREACHABLE();
+}
+
+
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
 
   // Write out the library object.
   ReserveHeader();
   WriteObject(lib.raw());
   FillHeader(kind());
   UnmarkAll();
 }
 
@@ skipping 11 matching lines @@
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   WriteObject(obj.raw());
   UnmarkAll();
 }
 
 
 }  // namespace dart