Fix for issue 20992 - Allow sending static/top-level functions to other isolates which are spawned …

runtime/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/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
@@ skipping 219 matching lines @@
   str_ ^= ReadObjectImpl();
   cls = library_.LookupClass(str_);
   if (cls.IsNull()) {
     SetReadException("Invalid object found in message.");
   }
   cls.EnsureIsFinalized(isolate());
   return cls.raw();
 }
 
 
+RawObject* SnapshotReader::ReadStaticImplicitClosure(intptr_t object_id,
+                                                     intptr_t class_header) {
+  ASSERT(kind_ == Snapshot::kMessage);
+
+  // First create a function object and associate it with the specified
+  // 'object_id'.
+  Function& func = Function::ZoneHandle(isolate(), Function::null());
+  AddBackRef(object_id, &func, kIsDeserialized);
+
+  // Read the library/class/function information and lookup the function.
+  str_ ^= ReadObjectImpl();
+  library_ = Library::LookupLibrary(str_);
+  if (library_.IsNull() || !library_.Loaded()) {
+    SetReadException("Invalid Library object found in message.");
+  }
+  str_ ^= ReadObjectImpl();
+  if (str_.Equals(Symbols::TopLevel())) {
+    str_ ^= ReadObjectImpl();
+    func = library_.LookupFunctionAllowPrivate(str_);
+  } else {
+    cls_ = library_.LookupClassAllowPrivate(str_);
+    if (cls_.IsNull()) {
+      OS::Print("Name of class not found %s\n", str_.ToCString());
+      SetReadException("Invalid Class object found in message.");
+    }
+    cls_.EnsureIsFinalized(isolate());
+    str_ ^= ReadObjectImpl();
+    func = cls_.LookupFunctionAllowPrivate(str_);
+  }
+  if (func.IsNull()) {
+    SetReadException("Invalid function object found in message.");
+  }
+  func = func.ImplicitClosureFunction();
+  ASSERT(!func.IsNull());
+
+  // Return the associated implicit static closure.
+  return func.ImplicitStaticClosure();
+}
+
+
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == kSmiTag) {
     return NewInteger(value);
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
   return ReadObjectImpl(static_cast<intptr_t>(value));
 }
 
 
@@ skipping 55 matching lines @@
     object_id = NextAvailableObjectId();
   }
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<int32_t>();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
-  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
+  intptr_t header_id = SerializedHeaderData::decode(class_header);
+  if (header_id == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
     AddBackRef(object_id, &result, kIsNotDeserialized);
 
     cls_ ^= ReadObjectImpl();  // Read class information.
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_.id(), instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
     }
     return result.raw();
+  } else if (header_id == kStaticImplicitClosureObjectId) {
+    // We skip the tags that have been written as the implicit static
+    // closure is going to be created in this isolate or the canonical
+    // version already created in the isolate will be used.
+    ReadTags();
+    return ReadStaticImplicitClosure(object_id, class_header);
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
   intptr_t class_id = LookupInternalClass(class_header);
   if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
@@ skipping 591 matching lines @@
   }
   Object* object = GetBackRef(object_id);
   return object->raw();
 }
 
 
 RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<int32_t>();
   intptr_t tags = ReadTags();
-  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
+  intptr_t header_id = SerializedHeaderData::decode(class_header);
+  if (header_id == kInstanceObjectId) {
     // Object is regular dart instance.
     Instance* result = reinterpret_cast<Instance*>(GetBackRef(object_id));
     intptr_t instance_size = 0;
     if (result == NULL) {
       result = &(Instance::ZoneHandle(isolate(), Instance::null()));
       AddBackRef(object_id, result, kIsDeserialized);
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
       ASSERT(instance_size > 0);
@@ skipping 44 matching lines @@
       while (offset < instance_size) {
         result->SetFieldAtOffset(offset, Object::null_object());
         offset += kWordSize;
       }
       result->SetCreatedFromSnapshot();
     } else if (RawObject::IsCanonical(tags)) {
       *result = result->CheckAndCanonicalize(NULL);
       ASSERT(!result->IsNull());
     }
     return result->raw();
+  } else if (header_id == kStaticImplicitClosureObjectId) {
+    // We do not use the tags as the implicit static closure
+    // is going to be created in this isolate or the canonical
+    // version already created in the isolate will be used.
+    return ReadStaticImplicitClosure(object_id, class_header);
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   intptr_t class_id = LookupInternalClass(class_header);
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
       pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
@@ skipping 193 matching lines @@
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (RawObject::IsImplicitFieldClassId(class_id)) {
     WriteInstanceRef(raw, cls);
     return;
   }
-  // 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.
+  // Add object 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 having
+  // been serialized so that we do not serialize the object when we go through
+  // the forward list.
   forward_list_.MarkAndAddObject(raw, kIsSerialized);
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
@@ skipping 353 matching lines @@
   WriteTags(GetObjectTags(cls));
 
   // Write out the library url and class name.
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
   WriteObjectImpl(library->ptr()->url_);
   WriteObjectImpl(cls->ptr()->name_);
 }
 
 
+void SnapshotWriter::WriteStaticImplicitClosure(intptr_t object_id,
+                                                RawFunction* func,
+                                                intptr_t tags) {
+  // Write out the serialization header value for this object.
+  WriteInlinedObjectHeader(object_id);
+
+  // Indicate this is a static implicit closure object.
+  Write<int32_t>(SerializedHeaderData::encode(kStaticImplicitClosureObjectId));
+
+  // Write out the tags.
+  WriteTags(tags);
+
+  // Write out the library url, class name and signature function name.
+  RawClass* cls = GetFunctionOwner(func);
+  ASSERT(cls != Class::null());
+  RawLibrary* library = cls->ptr()->library_;
+  ASSERT(library != Library::null());
+  WriteObjectImpl(library->ptr()->url_);
+  WriteObjectImpl(cls->ptr()->name_);
+  WriteObjectImpl(func->ptr()->name_);
+}
+
+
 void SnapshotWriter::ArrayWriteTo(intptr_t object_id,
                                   intptr_t array_kind,
                                   intptr_t tags,
                                   RawSmi* length,
                                   RawTypeArguments* type_arguments,
                                   RawObject* data[]) {
   intptr_t len = Smi::Value(length);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
@@ skipping 13 matching lines @@
   for (intptr_t i = 0; i < len; i++) {
     if (is_canonical) {
       WriteObjectImpl(data[i]);
     } else {
       WriteObjectRef(data[i]);
     }
   }
 }
 
 
-void SnapshotWriter::CheckIfSerializable(RawClass* cls) {
+RawFunction* SnapshotWriter::IsSerializableClosure(RawClass* cls,
+                                                   RawObject* obj) {
   if (Class::IsSignatureClass(cls)) {
-    // We do not allow closure objects in an isolate message.
-    Isolate* isolate = Isolate::Current();
-    HANDLESCOPE(isolate);
+    // 'obj' is a closure as its class is a signature class, extract
+    // the function object to check if this closure can be sent in an
+    // isolate message.
+    RawFunction* func = Closure::GetFunction(obj);
+    // We only allow closure of top level methods or static functions in a
+    // class to be sent in isolate messages.
+    if (can_send_any_object() &&
+        Function::IsImplicitStaticClosureFunction(func)) {
+      return func;
+    }
+    // Not a closure of a top level method or static function, throw an
+    // exception as we do not allow these objects to be serialized.
+    HANDLESCOPE(isolate());
+
+    const Class& clazz = Class::Handle(isolate(), cls);
+    const Function& errorFunc = Function::Handle(isolate(), func);
+    ASSERT(!errorFunc.IsNull());
+
+    // All other closures are errors.
     const char* format = "Illegal argument in isolate message"
-                         " : (object is a closure - %s %s)";
+        " : (object is a closure - %s %s)";
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
-    const Class& clazz = Class::Handle(isolate, cls);
-    const Function& func = Function::Handle(isolate,
-                                            clazz.signature_function());
-    ASSERT(!func.IsNull());
     intptr_t len = OS::SNPrint(NULL, 0, format,
-                               clazz.ToCString(), func.ToCString()) + 1;
-    char* chars = isolate->current_zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, clazz.ToCString(), func.ToCString());
+                               clazz.ToCString(), errorFunc.ToCString()) + 1;
+    char* chars = isolate()->current_zone()->Alloc<char>(len);
+    OS::SNPrint(chars, len, format, clazz.ToCString(), errorFunc.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
+  return Function::null();
+}
+
+
+RawClass* SnapshotWriter::GetFunctionOwner(RawFunction* func) {
+  RawObject* owner = func->ptr()->owner_;
+  uword tags = GetObjectTags(owner);
+  intptr_t class_id = RawObject::ClassIdTag::decode(tags);
+  if (class_id == kClassCid) {
+    return reinterpret_cast<RawClass*>(owner);
+  }
+  ASSERT(class_id == kPatchClassCid);
+  return reinterpret_cast<RawPatchClass*>(owner)->ptr()->patched_class_;
+}
+
+
+void SnapshotWriter::CheckForNativeFields(RawClass* cls) {
   if (cls->ptr()->num_native_fields_ != 0) {
     // We do not allow objects with native fields in an isolate message.
-    Isolate* isolate = Isolate::Current();
-    HANDLESCOPE(Isolate::Current());
+    HANDLESCOPE(isolate());
     const char* format = "Illegal argument in isolate message"
                          " : (object extends NativeWrapper - %s)";
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
-    const Class& clazz = Class::Handle(isolate, cls);
+    const Class& clazz = Class::Handle(isolate(), cls);
     intptr_t len = OS::SNPrint(NULL, 0, format, clazz.ToCString()) + 1;
-    char* chars = isolate->current_zone()->Alloc<char>(len);
+    char* chars = isolate()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, clazz.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
 }
 
 
 void SnapshotWriter::SetWriteException(Exceptions::ExceptionType type,
                                        const char* msg) {
   set_exception_type(type);
   set_exception_msg(msg);
   // The more specific error is set up in SnapshotWriter::ThrowException().
   isolate()->long_jump_base()->
       Jump(1, Object::snapshot_writer_error());
 }
 
 
 void SnapshotWriter::WriteInstance(intptr_t object_id,
                                    RawObject* raw,
                                    RawClass* cls,
                                    intptr_t tags) {
-  // First check if object is a closure or has native fields.
-  CheckIfSerializable(cls);
+  // Check if the instance has native fields and throw an exception if it does.
+  CheckForNativeFields(cls);
+
+  // Check if object is a closure that is serializable, if the object is a
+  // closure that is not serializable this will throw an exception.
+  RawFunction* func = IsSerializableClosure(cls, raw);
+  if (func != Function::null()) {
+    WriteStaticImplicitClosure(object_id, func, tags);
+    return;
+  }
 
   // Object is regular dart instance.
-  intptr_t next_field_offset =
+  intptr_t next_field_offset = Class::IsSignatureClass(cls) ?
+      Closure::InstanceSize() :
       cls->ptr()->next_field_offset_in_words_ << kWordSizeLog2;
   ASSERT(next_field_offset > 0);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Indicate this is an instance object.
   Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the tags.
@@ skipping 15 matching lines @@
     } else {
       WriteObjectRef(raw_obj);
     }
     offset += kWordSize;
   }
   return;
 }
 
 
 void SnapshotWriter::WriteInstanceRef(RawObject* raw, RawClass* cls) {
-  // First check if object is a closure or has native fields.
-  CheckIfSerializable(cls);
+  // Check if the instance has native fields and throw an exception if it does.
+  CheckForNativeFields(cls);
+
+  // Check if object is a closure that is serializable, if the object is a
+  // closure that is not serializable this will throw an exception.
+  RawFunction* func = IsSerializableClosure(cls, raw);
+  if (func != Function::null()) {
+    // Add object 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 having
+    // been serialized so that we do not serialize the object when we go through
+    // the forward list.
+    forward_list_.MarkAndAddObject(raw, kIsSerialized);
+    uword tags = raw->ptr()->tags_;
+    ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
+    intptr_t object_id = SerializedHeaderData::decode(tags);
+    tags = forward_list_.NodeForObjectId(object_id)->tags();
+    WriteStaticImplicitClosure(object_id, func, tags);
+    return;
+  }
 
   // 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.
   forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kOmittedObjectId);
 
@@ skipping 89 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart