36 TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
41 uint64_t
id = isolate->random()->NextJSInt();
53 int64_t
id = cap.Id();
54 int32_t hi =
static_cast<int32_t
>(
id >> 32);
55 int32_t lo =
static_cast<int32_t
>(
id);
62 TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
64 return isolate->CreateReceivePort(debug_name);
75 isolate->CloseReceivePort(port);
82 isolate->SetReceivePortKeepAliveState(port, active.value());
98 int64_t
id = port.Id();
99 int32_t hi =
static_cast<int32_t
>(
id >> 32);
100 int32_t lo =
static_cast<int32_t
>(
id);
117 const Dart_Port destination_port_id = port.Id();
118 const bool same_group =
InSameGroup(isolate, port);
135 static const char*
Name() {
return "UntaggedObjectPtrSetTraits"; }
154 working_set_(working_set) {}
160 if (visited_->GetValueExclusive(obj) == 1) {
163 visited_->SetValueExclusive(obj, 1);
164 working_set_->Add(obj);
169 for (
ObjectPtr* ptr = from; ptr <= to; ptr++) {
174#if defined(DART_COMPRESSED_POINTERS)
175 void VisitCompressedPointers(
uword heap_base,
179 VisitObject(ptr->Decompress(heap_base));
196 const char* exception_message =
nullptr;
209 std::unique_ptr<WeakTable> visited(
new WeakTable());
211 SendMessageValidator visitor(isolate->
group(), visited.get(), working_set);
213 visited->SetValueExclusive(obj.
ptr(), 1);
214 working_set->
Add(obj.
ptr());
216 while (!working_set->
is_empty() && (exception_message ==
nullptr)) {
228 const intptr_t batch_size = (2 << 14) - 1;
229 for (intptr_t i = 0; i < array.
Length(); ++i) {
231 visitor.VisitObject(ptr);
232 if ((i & batch_size) == batch_size) {
241 working_set->
Add(closure.RawContext());
244#define MESSAGE_SNAPSHOT_ILLEGAL(type) \
246 illegal_object = raw; \
247 exception_message = "is a " #type; \
261 klass = class_table->
At(
cid);
263 illegal_object = raw;
265 "is unsendable object (see restrictions listed at"
266 "`SendPort.send()` documentation for more information)";
273 ASSERT((exception_message ==
nullptr) == illegal_object.
IsNull());
274 if (exception_message !=
nullptr) {
275 working_set->
Clear();
278 args.SetAt(0, illegal_object);
283 zone, isolate, obj, illegal_object,
285 exception_message)));
300 if (!port.IsNull()) {
303 const bool same_group =
InSameGroup(isolate, port);
313 "for isolates in one isolate group."));
327 msg_array.
SetAt(0, msg_obj);
328 if (validated_result.IsUnhandledException()) {
333 isolate->group()->api_state()->AllocatePersistentHandle();
335 isolate->bequeath(std::unique_ptr<Bequest>(
new Bequest(handle, port.Id())));
342 error.set_is_user_initiated(
true);
387 return closure_tuple_handle_ ==
nullptr;
393 return closure_tuple_handle_;
408 const char* script_url_;
409 const char* package_config_;
410 const char* debug_name_;
413 std::unique_ptr<Message> serialized_args_;
414 std::unique_ptr<Message> serialized_message_;
418 bool errors_are_fatal_;
422 size_t len = strlen(chars);
423 char* mem =
new char[len + 1];
424 memmove(mem, chars, len + 1);
430 const char* script_url,
433 const char* package_config,
435 bool errors_are_fatal,
438 const char* debug_name,
440 : parent_port_(parent_port),
441 origin_id_(origin_id),
442 on_exit_port_(on_exit_port),
443 on_error_port_(on_error_port),
444 script_url_(script_url),
445 package_config_(package_config),
446 debug_name_(debug_name),
447 closure_tuple_handle_(closure_tuple_handle),
448 isolate_group_(isolate_group),
449 serialized_args_(nullptr),
450 serialized_message_(message_buffer->StealMessage()),
452 errors_are_fatal_(errors_are_fatal) {
453 ASSERT(closure_tuple_handle_ !=
nullptr);
456 auto isolate = thread->isolate();
463 const char* script_url,
464 const char* package_config,
468 bool errors_are_fatal,
471 const char* debug_name,
473 : parent_port_(parent_port),
474 on_exit_port_(on_exit_port),
475 on_error_port_(on_error_port),
476 script_url_(script_url),
477 package_config_(package_config),
478 debug_name_(debug_name),
479 isolate_group_(isolate_group),
480 serialized_args_(args_buffer->StealMessage()),
481 serialized_message_(message_buffer->StealMessage()),
484 errors_are_fatal_(errors_are_fatal) {
485 if (debug_name_ ==
nullptr) {
495 delete[] script_url_;
496 delete[] package_config_;
497 delete[] debug_name_;
514 if (obj.IsFunction()) {
522 "Unable to resolve function 'main' in script '%s'.",
script_url()));
523 return LanguageError::New(msg);
542 serialized_args_.reset();
549 serialized_message_.reset();
562 std::unique_ptr<IsolateSpawnState>
state)
563 : parent_isolate_(parent_isolate), state_(
std::move(
state)) {
568 if (parent_isolate_ !=
nullptr) {
574 const char*
name = state_->debug_name();
577 auto group = state_->isolate_group();
578 if (group ==
nullptr) {
589 if (create_group_callback ==
nullptr) {
590 FailedSpawn(
"Isolate spawn is not supported by this Dart embedder\n");
594 char*
error =
nullptr;
612 const bool is_parent_main_isolate =
613 strcmp(parent_isolate_->
name(),
"main") == 0;
617 (create_group_callback)(state_->script_url(),
name,
nullptr,
618 state_->package_config(), &api_flags,
621 parent_isolate_ =
nullptr;
623 if (isolate ==
nullptr) {
624 FailedSpawn(
error,
false);
635 if (initialize_callback ==
nullptr) {
637 "Lightweight isolate spawn is not supported by this Dart embedder\n",
642 char*
error =
nullptr;
644 auto group = state_->isolate_group();
647 parent_isolate_ =
nullptr;
649 if (isolate ==
nullptr) {
650 FailedSpawn(
error,
false);
655 void* child_isolate_data =
nullptr;
656 const bool success = initialize_callback(&child_isolate_data, &
error);
670 if (!EnsureIsRunnable(child)) {
675 state_->set_isolate(child);
685 TransitionNativeToVM transition(thread);
686 StackZone zone(thread);
687 HandleScope hs(thread);
689 success = EnqueueEntrypointInvocationAndNotifySpawner(thread);
699 char*
error =
nullptr;
701 state_->on_exit_port(), &
error)) {
702 FATAL(
"Dart_RunLoopAsync() failed: %s. Please file a Dart VM bug report.",
707 bool EnsureIsRunnable(Isolate* child) {
712 if (!child->is_runnable()) {
713 const char*
error = child->MakeRunnable();
714 if (
error !=
nullptr) {
719 ASSERT(child->is_runnable());
723 bool EnqueueEntrypointInvocationAndNotifySpawner(Thread* thread) {
724 auto isolate = thread->isolate();
725 auto zone = thread->zone();
726 const bool is_spawn_uri = state_->is_spawn_uri();
730 if (state_->closure_tuple_handle() !=
nullptr) {
736 "Failed to deserialize the passed entrypoint to the new isolate.");
744 ReportError(
"Failed to resolve entrypoint function.");
749 func = func.ImplicitClosureFunction();
750 entrypoint_closure = func.ImplicitStaticClosure();
754 const auto& args_obj =
Object::Handle(zone, state_->BuildArgs(thread));
755 if (args_obj.IsError()) {
757 "Failed to deserialize the passed arguments to the new isolate.");
760 ASSERT(args_obj.IsNull() || args_obj.IsInstance());
761 const auto& message_obj =
763 if (message_obj.IsError()) {
765 "Failed to deserialize the passed arguments to the new isolate.");
768 ASSERT(message_obj.IsNull() || message_obj.IsInstance());
770 args.SetAt(0, entrypoint_closure);
771 args.SetAt(1, args_obj);
772 args.SetAt(2, message_obj);
777 const auto& entry_point =
779 ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
783 ReportError(
"Failed to enqueue delayed entrypoint invocation.");
792 capabilities.SetAt(0, capability);
794 capabilities.SetAt(1, capability);
795 const auto& send_port =
799 message.SetAt(1, capabilities);
800 if (state_->paused()) {
801 capability ^= capabilities.At(0);
802 const bool added = isolate->AddResumeCapability(capability);
804 isolate->message_handler()->increment_paused();
809 state_->parent_port(),
816 void FailedSpawn(
const char*
error,
bool has_current_isolate =
true) {
817 ReportError(
error !=
nullptr
819 :
"Unknown error occurred during Isolate spawning.");
823 if (has_current_isolate) {
826 }
else if (state_->isolate_group() !=
nullptr) {
828 const bool kBypassSafepoint =
false;
841 void ReportError(
const char*
error) {
851 Isolate* parent_isolate_;
852 std::unique_ptr<IsolateSpawnState> state_;
859 char*
result =
new char[len + 1];
883 ASSERT(closure_copy_tuple.IsArray());
885 Object::Handle(zone, Array::Cast(closure_copy_tuple).At(0)).IsClosure());
886 closure_tuple_handle =
887 isolate->group()->api_state()->AllocatePersistentHandle();
888 closure_tuple_handle->
set_ptr(closure_copy_tuple.ptr());
890 bool fatal_errors = fatalErrors.IsNull() ?
true : fatalErrors.value();
900 const char* utf8_package_config =
901 packageConfig.IsNull() ? nullptr :
String2UTF8(packageConfig);
902 const char* utf8_debug_name =
903 debugName.IsNull() ? nullptr :
String2UTF8(debugName);
904 if (closure_tuple_handle !=
nullptr && utf8_debug_name ==
nullptr) {
907 NewConstChar(closure_function.QualifiedUserVisibleNameCString());
911 port.Id(), isolate->origin_id(),
String2UTF8(script_uri),
912 closure_tuple_handle, &message_buffer, utf8_package_config,
913 paused.value(), fatal_errors, on_exit_port, on_error_port,
914 utf8_debug_name, isolate->group()));
925 const char*
result =
nullptr;
928 if (isolate_group->HasTagHandler()) {
931 if (obj.IsString()) {
933 }
else if (obj.IsError()) {
935 error_obj ^= obj.
ptr();
940 "Unable to canonicalize uri '%s': "
941 "library tag handler returned wrong type",
946 "Unable to canonicalize uri '%s': no library tag handler found.",
966 bool fatal_errors = fatalErrors.IsNull() ?
true : fatalErrors.value();
986 char*
error =
nullptr;
988 if (canonical_uri ==
nullptr) {
993 const char* utf8_package_config =
994 packageConfig.IsNull() ? nullptr :
String2UTF8(packageConfig);
995 const char* utf8_debug_name =
996 debugName.IsNull() ? nullptr :
String2UTF8(debugName);
999 port.Id(), canonical_uri, utf8_package_config, &arguments_buffer,
1000 &message_buffer, paused.value(), fatal_errors, on_exit_port,
1001 on_error_port, utf8_debug_name,
nullptr));
1005 if (!checked.IsNull()) {
1018 if (
name ==
nullptr) {
1036 Library::Handle(zone, isolate->group()->object_store()->root_library());
1037 return root_lib.
url();
1042 arguments->NativeArgAt(0));
1044 if (register_kernel_blob_callback ==
nullptr) {
1046 "Registration of kernel blobs is not supported by this Dart embedder.");
1048 bool is_kernel =
false;
1052 Dart_IsKernel(
reinterpret_cast<uint8_t*
>(kernel_blob.DataAddr(0)),
1053 kernel_blob.LengthInBytes());
1057 zone,
String::New(
"kernelBlob doesn\'t contain a valid kernel.\n"));
1061 const char* uri =
nullptr;
1064 uri = register_kernel_blob_callback(
1065 reinterpret_cast<uint8_t*
>(kernel_blob.DataAddr(0)),
1066 kernel_blob.LengthInBytes());
1068 if (uri ==
nullptr) {
1076 arguments->NativeArgAt(0));
1077 auto unregister_kernel_blob_callback =
1079 if (unregister_kernel_blob_callback ==
nullptr) {
1081 "Registration of kernel blobs is not supported by this Dart embedder.");
1083 unregister_kernel_blob_callback(kernel_blob_uri.ToCString());
1104 if (!
error.IsNull()) {
1121 return TypedDataBase::Cast(
instance).LengthInBytes();
1131 TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
1134 arguments->NativeArgAt(1));
1137 intptr_t array_length;
1138 if (array_instance.IsGrowableObjectArray()) {
1139 const auto& growable_array = GrowableObjectArray::Cast(array_instance);
1140 array ^= growable_array.data();
1141 array_length = growable_array.
Length();
1142 }
else if (array_instance.IsArray()) {
1143 array ^= Array::Cast(array_instance).
ptr();
1144 array_length = array.
Length();
1150 uint64_t total_bytes = 0;
1152 for (intptr_t i = 0; i < array_length; i++) {
1155 if (total_bytes > kMaxBytes) {
1157 error_args.
SetAt(0, array);
1161 "Aggregated list exceeds max size %" Pu64 "", kMaxBytes)));
1167 uint8_t*
data =
reinterpret_cast<uint8_t*
>(
::malloc(total_bytes));
1168 if (
data ==
nullptr) {
1170 thread->isolate_group()->object_store()->out_of_memory());
1175 for (intptr_t i = 0; i < array_length; i++) {
1180 const auto& typed_data = TypedDataBase::Cast(
instance);
1181 const intptr_t length_in_bytes = typed_data.LengthInBytes();
1183 void*
source = typed_data.DataAddr(0);
1186 offset += length_in_bytes;
1195 arguments->NativeArgAt(0));
1200 peer = thread->heap()->GetPeer(t.ptr());
1209 if (
data ==
nullptr) {
1211 "Attempt to materialize object that was transferred already."));
1220 thread->heap()->SpaceForExternal(
length)));
1226 ASSERT(finalizable_ref !=
nullptr);
1227 return typed_data.
ptr();
static uint32_t hash(const SkShaderBase::GradientInfo &v)
static ArrayPtr New(intptr_t len, Heap::Space space=Heap::kNew)
virtual TypeArgumentsPtr GetTypeArguments() const
ObjectPtr At(intptr_t index) const
void SetAt(intptr_t index, const Object &value) const
static const Bool & False()
static const Bool & Get(bool value)
static const Bool & True()
static CapabilityPtr New(uint64_t id, Heap::Space space=Heap::kNew)
ClassPtr At(intptr_t cid) const
bool is_isolate_unsendable() const
static ObjectPtr InvokeFunction(const Function &function, const Array &arguments)
virtual const char * ToErrorCString() const
static DART_NORETURN void ThrowByType(ExceptionType type, const Array &arguments)
static DART_NORETURN void ThrowOOM()
static DART_NORETURN void ThrowUnsupportedError(const char *msg)
static DART_NORETURN void Throw(Thread *thread, const Instance &exception)
static DART_NORETURN void ThrowArgumentError(const Instance &arg)
static ObjectPtr Create(ExceptionType type, const Array &arguments)
static DART_NORETURN void PropagateError(const Error &error)
static ExternalTypedDataPtr New(intptr_t class_id, uint8_t *data, intptr_t len, Heap::Space space=Heap::kNew, bool perform_eager_msan_initialization_check=true)
static FinalizablePersistentHandle * New(IsolateGroup *isolate_group, const Object &object, void *peer, Dart_HandleFinalizer callback, intptr_t external_size, bool auto_delete)
void EnsureFreedExternal(IsolateGroup *isolate_group)
static IntegerPtr New(const String &str, Heap::Space space=Heap::kNew)
static IsolateGroup * Current()
ClassTable * class_table() const
const char * script_url() const
Dart_Port parent_port() const
void set_isolate(Isolate *value)
const char * debug_name() const
PersistentHandle * closure_tuple_handle() const
Dart_Port on_error_port() const
const char * package_config() const
bool is_spawn_uri() const
ObjectPtr ResolveFunction()
IsolateSpawnState(Dart_Port parent_port, Dart_Port origin_id, const char *script_url, PersistentHandle *closure_tuple_handle, SerializedObjectBuffer *message_buffer, const char *package_config, bool paused, bool errorsAreFatal, Dart_Port onExit, Dart_Port onError, const char *debug_name, IsolateGroup *group)
IsolateGroup * isolate_group() const
ObjectPtr BuildArgs(Thread *thread)
Dart_IsolateFlags * isolate_flags()
Dart_Port origin_id() const
ObjectPtr BuildMessage(Thread *thread)
bool errors_are_fatal() const
Isolate * isolate() const
Dart_Port on_exit_port() const
static Isolate * Current()
void FlagsCopyTo(Dart_IsolateFlags *api_flags) const
MallocGrowableArray< ObjectPtr > * pointers_to_verify_at_exit()
void DecrementSpawnCount()
static std::unique_ptr< char[]> LookupIsolateNameByPort(Dart_Port port)
void * init_callback_data() const
void set_forward_table_new(WeakTable *table)
IsolateGroup * group() const
static Dart_IsolateGroupCreateCallback CreateGroupCallback()
void set_init_callback_data(void *value)
static Dart_UnregisterKernelBlobCallback UnregisterKernelBlobCallback()
static Dart_InitializeIsolateCallback InitializeCallback()
void IncrementSpawnCount()
void set_origin_id(Dart_Port id)
static Dart_RegisterKernelBlobCallback RegisterKernelBlobCallback()
const char * name() const
ObjectPtr LookupReExport(const String &name, ZoneGrowableArray< intptr_t > *visited=nullptr) const
static LibraryPtr IsolateLibrary()
FunctionPtr LookupFunctionAllowPrivate(const String &name) const
UntaggedObject * untag() const
intptr_t GetClassId() const
static ObjectPtr RawCast(ObjectPtr obj)
void set_ptr(ObjectPtr ref)
static bool PostMessage(std::unique_ptr< Message > message, bool before_events=false)
static bool IsReceiverInThisIsolateGroupOrClosed(Dart_Port receiver, IsolateGroup *group)
static SendPortPtr New(Dart_Port id, Heap::Space space=Heap::kNew)
Dart_Port origin_id() const
void set_message(std::unique_ptr< Message > message)
static SmiPtr New(intptr_t value)
SpawnIsolateTask(Isolate *parent_isolate, std::unique_ptr< IsolateSpawnState > state)
~SpawnIsolateTask() override
void RunLightweight(const char *name)
void RunHeavyweight(const char *name)
static StringPtr NewFormatted(const char *format,...) PRINTF_ATTRIBUTE(1
static StringPtr New(const char *cstr, Heap::Space space=Heap::kNew)
void ToUTF8(uint8_t *utf8_array, intptr_t array_len) const
static const char * ToCString(Thread *thread, StringPtr ptr)
static Thread * Current()
static void ExitIsolateGroupAsHelper(bool bypass_safepoint)
IsolateGroup * isolate_group() const
static bool EnterIsolateGroupAsHelper(IsolateGroup *isolate_group, TaskKind kind, bool bypass_safepoint)
FinalizablePersistentHandle * handle() const
static TransferableTypedDataPtr New(uint8_t *data, intptr_t len)
static intptr_t MaxElements(intptr_t class_id)
static UnhandledExceptionPtr New(const Instance &exception, const Instance &stacktrace, Heap::Space space=Heap::kNew)
static bool IsMatch(const ObjectPtr a, const ObjectPtr b)
static const char * Name()
static bool ReportStats()
static uword Hash(const ObjectPtr obj)
intptr_t VisitPointers(ObjectPointerVisitor *visitor)
static UnwindErrorPtr New(const String &message, Heap::Space space=Heap::kNew)
static intptr_t Length(int32_t ch)
char * PrintToString(const char *format,...) PRINTF_ATTRIBUTE(2
struct _Dart_Isolate * Dart_Isolate
FlutterSemanticsFlag flags
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
const uint8_t uint32_t uint32_t GError ** error
#define MESSAGE_SNAPSHOT_ILLEGAL(type)
static ObjectPtr ValidateMessageObject(Zone *zone, Isolate *isolate, const Object &obj)
@ kInternalToIsolateGroup
ObjectPtr ReadMessage(Thread *thread, Message *message)
DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate)
bool CanShareObjectAcrossIsolates(ObjectPtr obj)
static const char * NewConstChar(const char *chars)
DART_EXPORT bool Dart_IsKernel(const uint8_t *buffer, intptr_t buffer_size)
ObjectPtr ReadObjectGraphCopyMessage(Thread *thread, PersistentHandle *handle)
const char * FindRetainingPath(Zone *zone_, Isolate *isolate, const Object &from, const Object &to, TraversalRules traversal_rules)
static bool InSameGroup(Isolate *sender, const SendPort &receiver)
void * malloc(size_t size)
static ObjectPtr DeserializeMessage(Thread *thread, Message *message)
ObjectPtr CopyMutableObjectGraph(const Object &object)
static void ThrowIsolateSpawnException(const String &message)
static const char * String2UTF8(const String &str)
DART_EXPORT bool Dart_RunLoopAsync(bool errors_are_fatal, Dart_Port on_error_port, Dart_Port on_exit_port, char **error)
std::unique_ptr< Message > WriteMessage(bool same_group, const Object &obj, Dart_Port dest_port, Message::Priority priority)
static const char * CanonicalizeUri(Thread *thread, const Library &library, const String &uri, char **error)
DART_EXPORT bool Dart_PostCObject(Dart_Port port_id, Dart_CObject *message)
Isolate * CreateWithinExistingIsolateGroup(IsolateGroup *group, const char *name, char **error)
static int8_t data[kExtLength]
DART_EXPORT void Dart_ShutdownIsolate()
static void ExternalTypedDataFinalizer(void *isolate_callback_data, void *peer)
static intptr_t GetTypedDataSizeOrThrow(const Instance &instance)
#define DEFINE_NATIVE_ENTRY(name, type_argument_count, argument_count)
#define GET_NATIVE_ARGUMENT(type, name, value)
#define GET_NON_NULL_NATIVE_ARGUMENT(type, name, value)
union _Dart_CObject::@86 value
#define TIMELINE_DURATION(thread, stream, name)