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"
 #include "vm/heap.h"
+#include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 4;
 
@@ skipping 711 matching lines @@
   *TypeArgumentsHandle() ^= ReadObjectImpl();
   result.SetTypeArguments(*TypeArgumentsHandle());
 
   for (intptr_t i = 0; i < len; i++) {
     *ObjectHandle() = ReadObjectRef();
     result.SetAt(i, *ObjectHandle());
   }
 }
 
 
+SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
+               uint8_t** buffer,
+               ReAlloc alloc,
+               intptr_t increment_size)
+    : BaseWriter(buffer, alloc, increment_size),
+      kind_(kind),
+      object_store_(Isolate::Current()->object_store()),
+      class_table_(Isolate::Current()->class_table()),
+      forward_list_(),
+      exception_type_(Exceptions::kNone),
+      exception_msg_(NULL),
+      error_(LanguageError::Handle()) {
+}
+
+
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
 
 
 void SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
   // Check if it is a singleton null object.
   if (rawobj == Object::null()) {
     WriteVMIsolateObject(kNullObject);
@@ skipping 40 matching lines @@
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   NoGCScope 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.
+      set_exception_type(Exceptions::kArgumentError);
+      // TODO(asiva): Allocate these constant strings once in the VM isolate.
+      set_exception_msg("Illegal argument in isolate message"
+                        " : (object is a closure)");
+      Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
+    }
     // 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 64 matching lines @@
   UNREACHABLE();
 }
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
-  // Reserve space in the output buffer for a snapshot header.
-  ReserveHeader();
+  // Setup for long jump in case there is an exception while writing
+  // the snapshot.
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  // TODO(asiva): Allocate these constant strings once in the VM isolate.
+  *ErrorHandle() = LanguageError::New(
+      String::Handle(String::New("Error while writing full snapshot")));
+  if (setjmp(*jump.Set()) == 0) {
+    NoGCScope no_gc;
 
-  // Write out all the objects in the object store of the isolate which
-  // is the root set for all dart allocated objects at this point.
-  SnapshotWriterVisitor visitor(this, false);
-  object_store->VisitObjectPointers(&visitor);
+    // Reserve space in the output buffer for a snapshot header.
+    ReserveHeader();
 
-  // Write out all forwarded objects.
-  WriteForwardedObjects();
+    // Write out all the objects in the object store of the isolate which
+    // is the root set for all dart allocated objects at this point.
+    SnapshotWriterVisitor visitor(this, false);
+    object_store->VisitObjectPointers(&visitor);
 
-  FillHeader(kind());
-  UnmarkAll();
+    // Write out all forwarded objects.
+    WriteForwardedObjects();
+
+    FillHeader(kind());
+    UnmarkAll();
+
+    isolate->set_long_jump_base(base);
+  } else {
+    isolate->set_long_jump_base(base);
+    ThrowException(exception_type(), exception_msg());
+  }
 }
 
 
 uword SnapshotWriter::GetObjectTags(RawObject* raw) {
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     return forward_list_[id - kMaxPredefinedObjectIds]->tags();
   } else {
     return tags;
@@ skipping 113 matching lines @@
   //    ......
   NoGCScope 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.
+      set_exception_type(Exceptions::kArgumentError);
+      // TODO(asiva): Allocate these constant strings once in the VM isolate.
+      set_exception_msg("Illegal argument in isolate message"
+                        " : (object is a closure)");
+      Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
+    }
+    if (cls->ptr()->num_native_fields_ != 0) {
+      // We do not allow objects with native fields in an isolate message.
+      set_exception_type(Exceptions::kArgumentError);
+      // TODO(asiva): Allocate these constant strings once in the VM isolate.
+      set_exception_msg("Illegal argument in isolate message"
+                        " : (object extends NativeWrapper)");
+
+      Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
+    }
     // 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::ThrowException(Exceptions::ExceptionType type,
+                                    const char* msg) {
+  Isolate::Current()->object_store()->clear_sticky_error();
+  UnmarkAll();
+  const String& msg_obj = String::Handle(String::New(msg));
+  GrowableArray<const Object*> args(1);
+  args.Add(&msg_obj);
+  Exceptions::ThrowByType(type, args);
+  UNREACHABLE();
+}
+
+
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
 
-  // Write out the library object.
-  ReserveHeader();
-  WriteObject(lib.raw());
-  FillHeader(kind());
-  UnmarkAll();
+  // Setup for long jump in case there is an exception while writing
+  // the snapshot.
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  *ErrorHandle() = LanguageError::New(
+      String::Handle(String::New("Error while writing script snapshot")));
+  if (setjmp(*jump.Set()) == 0) {
+    // Write out the library object.
+    NoGCScope no_gc;
+    ReserveHeader();
+    WriteObject(lib.raw());
+    FillHeader(kind());
+    UnmarkAll();
+    isolate->set_long_jump_base(base);
+  } else {
+    isolate->set_long_jump_base(base);
+    ThrowException(exception_type(), exception_msg());
+  }
 }
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
-  WriteObject(obj.raw());
-  UnmarkAll();
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+
+  // Setup for long jump in case there is an exception while writing
+  // the message.
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  *ErrorHandle() = LanguageError::New(
+      String::Handle(String::New("Error while writing message")));
+  if (setjmp(*jump.Set()) == 0) {
+    NoGCScope no_gc;
+    WriteObject(obj.raw());
+    UnmarkAll();
+    isolate->set_long_jump_base(base);
+  } else {
+    isolate->set_long_jump_base(base);
+    ThrowException(exception_type(), exception_msg());
+  }
 }
 
 
 }  // namespace dart