60#if !defined(DART_PRECOMPILED_RUNTIME)
71#if defined(DEBUG) && !defined(DART_PRECOMPILED_RUNTIME)
73 check_function_fingerprints,
75 "Check function fingerprints");
80 "Verify correct API acquire/release of typed data.");
84 "Dump common hash tables before snapshotting.");
86 enable_deprecated_wait_for,
88 "Enable deprecated dart:cli waitFor. "
89 "This feature will be fully removed in Dart 3.4 release. "
90 "See https://dartbug.com/52121.");
92#define CHECK_ERROR_HANDLE(error) \
94 ErrorPtr err = (error); \
95 if (err != Error::null()) { \
96 return Api::NewHandle(T, err); \
105Dart_Handle Api::no_callbacks_error_handle_ =
nullptr;
106Dart_Handle Api::unwind_in_progress_error_handle_ =
nullptr;
109 if (strncmp(func,
"dart::", 6) == 0) {
120class CheckFunctionTypesVisitor :
public ObjectVisitor {
122 explicit CheckFunctionTypesVisitor(Thread* thread)
123 : classHandle_(Class::Handle(thread->zone())),
124 funcHandle_(Function::Handle(thread->zone())),
125 typeHandle_(AbstractType::Handle(thread->zone())) {}
127 void VisitObject(ObjectPtr obj)
override {
128 if (obj->IsFunction()) {
130 classHandle_ ^= funcHandle_.Owner();
133 typeHandle_ ^= funcHandle_.result_type();
134 ASSERT(typeHandle_.IsTypeParameter() || typeHandle_.IsCanonical());
137 const intptr_t num_parameters = funcHandle_.NumParameters();
138 for (intptr_t i = 0; i < num_parameters; i++) {
139 typeHandle_ = funcHandle_.ParameterTypeAt(i);
140 ASSERT(typeHandle_.IsTypeParameter() || typeHandle_.IsCanonical());
147 Function& funcHandle_;
148 AbstractType& typeHandle_;
153 if (obj.IsInstance()) {
155 const Type& list_rare_type =
156 Type::Handle(zone, object_store->non_nullable_list_rare_type());
170 if (obj.IsInstance()) {
172 const Type& map_rare_type =
173 Type::Handle(zone, object_store->non_nullable_map_rare_type());
187#if defined(DART_PRECOMPILED_RUNTIME)
194 zone, isolate_group->object_store()->compiletime_error_class());
213 Object& obj = thread->ObjectHandle();
238 int64_t arg_value = 0;
240 *
value =
static_cast<uint64_t
>(arg_value);
256 intptr_t* field_values,
257 const char* current_func) {
258 ASSERT(field_values !=
nullptr);
266 Object& obj = thread->ObjectHandle();
269 memset(field_values, 0, (num_fields *
sizeof(field_values[0])));
274 if (!obj.IsInstance()) {
276 "%s expects argument at index '%d' to be of"
278 current_func, arg_index);
281 int field_count =
instance.NumNativeFields();
282 ASSERT(num_fields != field_count);
283 return Api::NewError(
"%s: expected %d 'num_fields' but was passed in %d.",
284 current_func, field_count, num_fields);
299 const intptr_t kNumArgs = 1;
311 const intptr_t kNumArgs = 2;
325 const intptr_t kNumArgs = 3;
340 const char* str =
error.ToErrorCString();
341 intptr_t len = strlen(str) + 1;
343 strncpy(str_copy, str, len);
345 if ((len > 1) && (str_copy[len - 2] ==
'\n')) {
346 str_copy[len - 2] =
'\0';
354Dart_Handle Api::InitNewHandle(Thread* thread, ObjectPtr raw) {
356 ASSERT(local_handles !=
nullptr);
357 LocalHandle* ref = local_handles->AllocateHandle();
359 return ref->apiHandle();
373 return InitNewHandle(thread, raw);
385 return (
reinterpret_cast<LocalHandle*
>(
object))->ptr();
388#define DEFINE_UNWRAP(type) \
389 const type& Api::Unwrap##type##Handle(Zone* zone, Dart_Handle dart_handle) { \
390 const Object& obj = Object::Handle(zone, Api::UnwrapHandle(dart_handle)); \
391 if (obj.Is##type()) { \
392 return type::Cast(obj); \
394 return type::Handle(zone); \
403 if (ref.IsString()) {
404 return String::Cast(ref);
406 return Object::null_string();
410 const ReusableObjectHandleScope& reuse,
414 if (ref.IsInstance()) {
415 return Instance::Cast(ref);
417 return Object::null_instance();
480 if (!
error.IsError()) {
504 ASSERT(thread !=
nullptr);
526 ASSERT(isolate !=
nullptr);
531 ASSERT(true_handle_ ==
nullptr);
534 ASSERT(false_handle_ ==
nullptr);
537 ASSERT(null_handle_ ==
nullptr);
540 ASSERT(empty_string_handle_ ==
nullptr);
543 ASSERT(no_callbacks_error_handle_ ==
nullptr);
544 no_callbacks_error_handle_ =
547 ASSERT(unwind_in_progress_error_handle_ ==
nullptr);
548 unwind_in_progress_error_handle_ =
553 true_handle_ =
nullptr;
554 false_handle_ =
nullptr;
555 null_handle_ =
nullptr;
556 empty_string_handle_ =
nullptr;
557 no_callbacks_error_handle_ =
nullptr;
558 unwind_in_progress_error_handle_ =
nullptr;
566 if (!raw_obj->IsHeapObject()) {
570 if (
cid == kOneByteStringCid ||
cid == kTwoByteStringCid) {
573 return (*peer !=
nullptr);
581 if (raw_obj->IsHeapObject()) {
585 TypedDataPtr native_fields =
586 reinterpret_cast<CompressedTypedDataPtr*
>(
592 *
value = *bit_cast<intptr_t*, uint8_t*>(native_fields->untag()->data());
605 if (raw_obj->IsHeapObject()) {
607 if (
cid == kBoolCid) {
608 *
value = (raw_obj == Object::bool_true().ptr());
624 if (raw_obj->IsHeapObject()) {
626 if (
cid == kMintCid) {
627 *
value =
static_cast<MintPtr
>(raw_obj)->
untag()->value_;
641 if (raw_obj->IsHeapObject()) {
643 if (
cid == kDoubleCid) {
644 *
value =
static_cast<DoublePtr
>(raw_obj)->
untag()->value_;
647 if (
cid == kMintCid) {
649 static_cast<double>(
static_cast<MintPtr
>(raw_obj)->
untag()->value_);
654 *
value =
static_cast<double>(
Smi::Value(
static_cast<SmiPtr
>(raw_obj)));
661 intptr_t* field_values) {
665 int class_num_fields = arguments->
thread()
670 ->num_native_fields_;
671 if (num_fields != class_num_fields) {
675 TypedDataPtr native_fields =
676 reinterpret_cast<CompressedTypedDataPtr*
>(
681 memset(field_values, 0, (num_fields *
sizeof(field_values[0])));
685 intptr_t* native_values =
686 reinterpret_cast<intptr_t*
>(native_fields->untag()->data());
687 memmove(field_values, native_values, (num_fields *
sizeof(field_values[0])));
705 ASSERT(
state->IsValidWeakPersistentHandle(handle));
718void FinalizablePersistentHandle::Finalize(
721 if (!handle->
ptr()->IsHeapObject()) {
732 state->ClearWeakPersistentHandle(handle);
738 state->FreeWeakPersistentHandle(handle);
798 return obj.IsUnhandledException();
804 if (obj.IsUnhandledException()) {
807 }
else if (obj.IsError()) {
808 return Api::NewError(
"This error is not an unhandled exception error.");
810 return Api::NewError(
"Can only get exceptions from error handles.");
817 if (obj.IsUnhandledException()) {
820 }
else if (obj.IsError()) {
821 return Api::NewError(
"This error is not an unhandled exception error.");
823 return Api::NewError(
"Can only get stacktraces from error handles.");
849 if ((class_id == kApiErrorCid) || (class_id == kLanguageErrorCid)) {
867 if (!obj.IsError()) {
869 "%s expects argument 'handle' to be an error handle. "
870 "Did you forget to check Dart_IsError first?",
876 FATAL(
"No Dart frames on stack, cannot propagate error.");
886 ErrorPtr raw_error = Api::UnwrapErrorHandle(thread->
zone(), handle).ptr();
899 if (obj.IsString()) {
901 }
else if (obj.IsInstance()) {
903 const Instance& receiver = Instance::Cast(obj);
922 if (object1.IsInstance() && object2.IsInstance()) {
923 return Instance::Cast(object1).IsIdenticalTo(Instance::Cast(object2));
1003 if (super_klass.IsNull()) {
1007 if (super_klass.Name() != Symbols::Struct().ptr() &&
1008 super_klass.Name() != Symbols::Union().ptr()) {
1012 return library.url() == Symbols::DartFfi().ptr();
1019 intptr_t external_allocation_size,
1021 if (!ref.
ptr()->IsHeapObject()) {
1024 if (ref.IsPointer()) {
1033 callback, external_allocation_size,
1035 return finalizable_ref ==
nullptr
1044 intptr_t external_allocation_size,
1055 intptr_t external_allocation_size,
1057 if (!ref.
ptr()->IsHeapObject()) {
1060 if (ref.IsPointer()) {
1069 callback, external_allocation_size,
1071 return finalizable_ref ==
nullptr ? nullptr
1079 intptr_t external_allocation_size,
1089 intptr_t external_allocation_size,
1103 intptr_t external_allocation_size,
1125 state->FreePersistentHandle(ref);
1137 ASSERT(
state->IsActiveWeakPersistentHandle(
object));
1139 weak_ref->EnsureFreedExternal(isolate_group);
1140 state->FreeWeakPersistentHandle(weak_ref);
1149 "%s expects arguments 'object' and 'strong_ref_to_object' to point to "
1169 "Dart_InitializeParams is null.");
1175 "Invalid Dart_InitializeParams version.");
1194#define ISOLATE_GROUP_METRIC_API(type, variable, name, unit) \
1195 DART_EXPORT int64_t Dart_IsolateGroup##variable##Metric( \
1196 Dart_IsolateGroup isolate_group) { \
1197 if (isolate_group == nullptr) { \
1198 FATAL("%s expects argument 'isolate_group' to be non-null.", \
1201 IsolateGroup* group = reinterpret_cast<IsolateGroup*>(isolate_group); \
1202 return group->Get##variable##Metric()->Value(); \
1205#undef ISOLATE_GROUP_METRIC_API
1207#if !defined(PRODUCT)
1208#define ISOLATE_METRIC_API(type, variable, name, unit) \
1209 DART_EXPORT int64_t Dart_Isolate##variable##Metric(Dart_Isolate isolate) { \
1210 if (isolate == nullptr) { \
1211 FATAL("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC); \
1213 Isolate* iso = reinterpret_cast<Isolate*>(isolate); \
1214 return iso->Get##variable##Metric()->Value(); \
1217#undef ISOLATE_METRIC_API
1219#define ISOLATE_METRIC_API(type, variable, name, unit) \
1220 DART_EXPORT int64_t Dart_Isolate##variable##Metric(Dart_Isolate isolate) { \
1224#undef ISOLATE_METRIC_API
1236 auto source = group->source();
1239 if (
error !=
nullptr) {
1246 bool success =
false;
1251#if defined(SUPPORT_TIMELINE)
1252 TimelineBeginEndScope tbes(
T, Timeline::GetIsolateStream(),
1253 "InitializeIsolate");
1254 tbes.SetNumArguments(1);
1255 tbes.CopyArgument(0,
"isolateName",
I->name());
1268 if (error_obj.IsNull()) {
1271 if (error_obj.IsNull()) {
1272#if defined(DEBUG) && !defined(DART_PRECOMPILED_RUNTIME)
1273 if (FLAG_check_function_fingerprints && !FLAG_precompiled_mode) {
1274 Library::CheckFunctionFingerprints();
1278 }
else if (
error !=
nullptr) {
1291 T->EnterSafepoint();
1292 if (
error !=
nullptr) {
1308 auto spawning_group = group;
1313 if (isolate ==
nullptr)
return nullptr;
1315 auto source = spawning_group->source();
1328 const uint8_t* snapshot_data,
1329 const uint8_t* snapshot_instructions,
1331 void* isolate_group_data,
1337 if (
flags ==
nullptr) {
1342 const char* non_null_name =
name ==
nullptr ?
"isolate" :
name;
1343 std::unique_ptr<IsolateGroupSource>
source(
1345 snapshot_instructions,
nullptr, -1, *
flags));
1350 flags->is_service_isolate ||
flags->is_kernel_isolate);
1353 non_null_name, isolate_data,
error);
1354 if (isolate !=
nullptr) {
1355 group->set_initial_spawn_successful();
1363 const uint8_t* kernel_buffer,
1364 intptr_t kernel_buffer_size,
1366 void* isolate_group_data,
1372 if (
flags ==
nullptr) {
1377 const char* non_null_name =
name ==
nullptr ?
"isolate" :
name;
1378 std::shared_ptr<IsolateGroupSource>
source(
1380 kernel_buffer, kernel_buffer_size, *
flags));
1386 flags->is_service_isolate ||
flags->is_kernel_isolate);
1388 non_null_name, isolate_data,
error);
1389 if (isolate !=
nullptr) {
1390 group->set_initial_spawn_successful();
1400 void* child_isolate_data,
1403 auto member =
reinterpret_cast<Isolate*
>(group_member);
1404 if (member->IsScheduled()) {
1405 FATAL(
"The given member isolate (%s) must not have been entered.",
1413 if (isolate !=
nullptr) {
1425 auto I =
T->isolate();
1436 I->WaitForOutstandingSpawns();
1440 while (scope !=
nullptr) {
1445 T->set_api_top_scope(
nullptr);
1467 if (isolate ==
nullptr) {
1471 return reinterpret_cast<Isolate*
>(isolate)->init_callback_data();
1488 return isolate_group->
id();
1492 if (isolate ==
nullptr) {
1496 return reinterpret_cast<Isolate*
>(isolate)->group()->embedder_data();
1504 static_cast<int64_t
>(
I->main_port()),
I->name()));
1509 if (thread ==
nullptr) {
1516 int64_t main_port =
static_cast<int64_t
>(
I->main_port());
1517 const char*
fmt =
"%s (%" Pd64 ")";
1518 int length = snprintf(
nullptr, 0,
fmt,
I->name(), main_port) + 1;
1520 snprintf(res,
length,
fmt,
I->name(), main_port);
1525 if (isolate ==
nullptr) {
1530 int64_t main_port =
static_cast<int64_t
>(
I->main_port());
1540 "Isolate %s is already scheduled on mutator thread %p, "
1541 "failed to schedule from os thread 0x%" Px "\n",
1552 T->EnterSafepoint();
1556#if !defined(PRODUCT)
1557 if (!FLAG_profiler) {
1558 FLAG_profiler =
true;
1565#if !defined(PRODUCT)
1566 if (FLAG_profiler) {
1568 FLAG_profiler =
false;
1574#if !defined(PRODUCT)
1576 if (os_thread ==
nullptr) {
1584#if !defined(PRODUCT)
1586 if (os_thread ==
nullptr) {
1604 if (!FLAG_profiler) {
1605 if (
error !=
nullptr) {
1611 const intptr_t kBufferLength = 512;
1612 char method[kBufferLength];
1615 intptr_t method_length = snprintf(method, kBufferLength,
"{"
1616 "\"jsonrpc\": \"2.0\","
1617 "\"method\": \"_writeCpuProfileTimeline\","
1620 " \"isolateId\": \"isolates/%" Pd64 "\","
1621 " \"tags\": \"None\""
1625 ASSERT(method_length <= kBufferLength);
1627 char* response =
nullptr;
1628 intptr_t response_length;
1630 reinterpret_cast<uint8_t*
>(method), method_length,
1631 reinterpret_cast<uint8_t**
>(&response), &response_length,
error);
1658 FATAL(
"%s expects the current isolate to not be runnable yet.",
1747 const Error& error_handle = Api::UnwrapErrorHandle(
Z,
error);
1752 if (!error_handle.IsUnhandledException() &&
1754 FATAL(
"%s expects the error to be an unhandled exception error or null.",
1787 T->isolate()->group()->idle_time_handler()->NotifyIdle(deadline);
1795 T->heap()->NotifyDestroyed();
1799#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
1805#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
1813#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
1822#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
1830 group->heap()->ReportSurvivingAllocations(
callback, context);
1837#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
1861 return T->heap()->SetMode(mode);
1879 intptr_t* vm_snapshot_data_size,
1880 uint8_t** isolate_snapshot_data_buffer,
1881 intptr_t* isolate_snapshot_data_size,
1883#if defined(DART_PRECOMPILED_RUNTIME)
1884 return Api::NewError(
"Cannot create snapshots on an AOT runtime.");
1888 if (vm_snapshot_data_buffer !=
nullptr) {
1904 CheckFunctionTypesVisitor check_canonical(
T);
1916 snapshot_kind, &vm_snapshot_data, &isolate_snapshot_data,
1917 nullptr ,
nullptr );
1919 if (vm_snapshot_data_buffer !=
nullptr) {
1920 *vm_snapshot_data_buffer = vm_snapshot_data.buffer();
1923 *isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();
1940 if (isolate ==
nullptr) {
1944 const char*
error =
reinterpret_cast<Isolate*
>(isolate)->MakeRunnable();
1945 if (
error !=
nullptr) {
2016 I->message_handler()->Run(
I->group()->thread_pool(),
nullptr,
2019 while (!
data.done) {
2028 return Api::NewError(
"Run method in isolate message handler failed");
2034 if (FLAG_print_class_table) {
2036 I->group()->class_table()->Print();
2046 auto isolate = thread->isolate();
2050 if (thread->api_top_scope() !=
nullptr) {
2055 if (!isolate->is_runnable()) {
2056 const char* error_msg = isolate->MakeRunnable();
2057 if (error_msg !=
nullptr) {
2063 isolate->SetErrorsFatal(errors_are_fatal);
2073 isolate->AddErrorListener(port);
2078 isolate->AddExitListener(port, Instance::null_instance());
2110 ASSERT(
I->GetAndClearResumeRequest() ==
false);
2112 I->message_handler()->HandleOOBMessages();
2113 bool resume =
I->GetAndClearResumeRequest();
2165 const SendPort& send_port = Api::UnwrapSendPortHandle(
Z, port);
2166 if (send_port.
IsNull()) {
2169 if (port_id ==
nullptr) {
2172 *port_id = send_port.
Id();
2202 if (thread !=
nullptr) {
2204 zone = scope->
zone();
2207 if (scope ==
nullptr)
return nullptr;
2208 zone = scope->
zone();
2210 return reinterpret_cast<uint8_t*
>(zone->
AllocUnsafe(size));
2264 }
else if (
result.IsError()) {
2277 return instance.IsInstanceOf(
type, Object::null_type_arguments(),
2278 Object::null_type_arguments());
2286 const Type& type_obj = Api::UnwrapTypeHandle(
Z,
type);
2293 "%s expects argument 'type' to be a fully resolved type.",
2314 Object& ref = thread->ObjectHandle();
2316 return ref.IsInstance();
2423 if (obj.IsClosure()) {
2424 const Closure& closure = Closure::Cast(obj);
2451 if (obj.IsInstance()) {
2463 auto isolate_group =
T->isolate_group();
2468 if (!obj.IsInstance()) {
2487 const Type& type_obj = Api::UnwrapTypeHandle(
Z, cls_type);
2494 "cls_type must be a Type object which represents a Class.");
2530 if (is_static ==
nullptr) {
2537 *is_static = func.is_static();
2544 if (closure_obj.
IsNull() || !closure_obj.IsClosure()) {
2550 FunctionPtr rf = Closure::Cast(closure_obj).function();
2556 const Type& type_obj = Api::UnwrapTypeHandle(
Z, cls_type);
2560 "cls_type must be a Type object which represents a Class.");
2588 const Integer& int_obj = Api::UnwrapIntegerHandle(
Z, integer);
2606 const Integer& int_obj = Api::UnwrapIntegerHandle(
Z, integer);
2610 ASSERT(int_obj.IsMint());
2644 return Api::NewError(
"%s: Cannot create Dart integer from string %s",
2662 const Integer& int_obj = Api::UnwrapIntegerHandle(
Z, integer);
2666 ASSERT(int_obj.IsMint());
2679 if (smi_value >= 0) {
2686 const Integer& int_obj = Api::UnwrapIntegerHandle(
Z, integer);
2690 if (int_obj.IsSmi()) {
2693 ASSERT(int_obj.IsMint());
2699 return Api::NewError(
"%s: Integer %s cannot be represented as a uint64_t.",
2704 const char** value) {
2707 const Integer& int_obj = Api::UnwrapIntegerHandle(
Z, integer);
2725 const Double& obj = Api::UnwrapDoubleHandle(
Z, double_obj);
2737 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
2742 const Type& type_obj = Api::UnwrapTypeHandle(
Z, cls_type);
2750 "cls_type must be a Type object which represents a Class");
2759 if (func_name.
IsNull()) {
2769 if (!func.is_static()) {
2770 return Api::NewError(
"function_name must refer to a static method.");
2773 if (func.
kind() != UntaggedFunction::kRegularFunction) {
2775 "function_name must be the name of a regular function.");
2806 const Bool& obj = Api::UnwrapBoolHandle(
Z, boolean_obj);
2820 ReusableObjectHandleScope reused_obj_handle(thread);
2834 ReusableObjectHandleScope reused_obj_handle(thread);
2847 if (str ==
nullptr) {
2858 if (utf8_array ==
nullptr &&
length != 0) {
2863 return Api::NewError(
"%s expects argument 'str' to be valid UTF-8.",
2873 if (utf16_array ==
nullptr &&
length != 0) {
2885 if (utf32_array ==
nullptr &&
length != 0) {
2894 const char** cstr) {
2897 if (cstr ==
nullptr) {
2906 if (res ==
nullptr) {
2909 const char* string_value = str_obj.
ToCString();
2910 memmove(res, string_value, string_length + 1);
2911 ASSERT(res[string_length] ==
'\0');
2917 uint8_t** utf8_array,
2921 if (utf8_array ==
nullptr) {
2933 if (*utf8_array ==
nullptr) {
2936 str_obj.
ToUTF8(*utf8_array, str_len);
2942 uint8_t* utf8_array,
2946 if (utf8_array ==
nullptr) {
2956 "Provided buffer is not large enough to hold "
2957 "the UTF-8 representation of the string");
2959 str_obj.
ToUTF8(utf8_array, str_len);
2964 uint8_t* latin1_array,
2968 if (latin1_array ==
nullptr) {
2978 intptr_t str_len = str_obj.
Length();
2979 intptr_t copy_len = (str_len > *
length) ? *
length : str_len;
2983 for (intptr_t i = 0; i < copy_len; i++) {
2984 latin1_array[i] = str_obj.
CharAt(i);
2991 uint16_t* utf16_array,
2999 intptr_t str_len = str_obj.
Length();
3000 intptr_t copy_len = (str_len > *
length) ? *
length : str_len;
3001 for (intptr_t i = 0; i < copy_len; i++) {
3002 utf16_array[i] = str_obj.
CharAt(i);
3013 if (size ==
nullptr) {
3017 ReusableObjectHandleScope reused_obj_handle(thread);
3028 intptr_t* char_size,
3035 ReusableObjectHandleScope reused_obj_handle(thread);
3057 switch (element_type_id) {
3061 return store->type_argument_legacy_int();
3063 return store->type_argument_legacy_string();
3074 "Cannot use legacy types with --sound-null-safety enabled. "
3075 "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
3098 const Type&
type = Api::UnwrapTypeHandle(
Z, element_type);
3099 if (
type.IsNull()) {
3102 if (!
type.IsFinalized()) {
3104 "%s expects argument 'type' to be a fully resolved type.",
3108 return Api::NewError(
"%s expects argument 'type' to be a nullable type.",
3120 const Type&
type = Api::UnwrapTypeHandle(
Z, element_type);
3121 if (
type.IsNull()) {
3124 if (!
type.IsFinalized()) {
3126 "%s expects argument 'type' to be a fully resolved type.",
3132 "%s expects argument 'fill_object' to have the same type as "
3138 "%s expects argument 'fill_object' to be non-null for a non-nullable "
3143 for (intptr_t i = 0; i < arr.
Length(); ++i) {
3149#define GET_LIST_LENGTH(zone, type, obj, len) \
3150 type& array = type::Handle(zone); \
3151 array ^= obj.ptr(); \
3152 *len = array.Length(); \
3153 return Api::Success();
3158 if (obj.IsError()) {
3162 if (obj.IsTypedDataBase()) {
3165 if (obj.IsArray()) {
3168 if (obj.IsGrowableObjectArray()) {
3177 "Object does not implement the List interface");
3181 if (retval.IsSmi()) {
3182 *len = Smi::Cast(retval).Value();
3184 }
else if (retval.IsMint()) {
3185 int64_t mint_value = Mint::Cast(retval).value();
3187 *len =
static_cast<intptr_t
>(mint_value);
3191 "Length of List object is greater than the "
3192 "maximum value that 'len' parameter can hold");
3193 }
else if (retval.IsError()) {
3196 return Api::NewError(
"Length of List object is not an integer");
3200#define GET_LIST_ELEMENT(thread, type, obj, index) \
3201 const type& array_obj = type::Cast(obj); \
3202 if ((index >= 0) && (index < array_obj.Length())) { \
3203 return Api::NewHandle(thread, array_obj.At(index)); \
3205 return Api::NewError("Invalid index passed into access list element");
3210 if (obj.IsArray()) {
3212 }
else if (obj.IsGrowableObjectArray()) {
3214 }
else if (obj.IsError()) {
3226 "Object does not implement the 'List' interface");
3230#define GET_LIST_RANGE(thread, type, obj, offset, length) \
3231 const type& array_obj = type::Cast(obj); \
3232 if ((offset >= 0) && (offset + length <= array_obj.Length())) { \
3233 for (intptr_t index = 0; index < length; ++index) { \
3234 result[index] = Api::NewHandle(thread, array_obj.At(index + offset)); \
3236 return Api::Success(); \
3238 return Api::NewError("Invalid offset/length passed into access list");
3249 if (obj.IsArray()) {
3251 }
else if (obj.IsGrowableObjectArray()) {
3253 }
else if (obj.IsError()) {
3260 const intptr_t kNumArgs = 2;
3266 for (intptr_t i = 0; i <
length; ++i) {
3268 args.SetAt(1, index);
3277 "Object does not implement the 'List' interface");
3281#define SET_LIST_ELEMENT(type, obj, index, value) \
3282 const type& array = type::Cast(obj); \
3283 const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value)); \
3284 if (!value_obj.IsNull() && !value_obj.IsInstance()) { \
3285 RETURN_TYPE_ERROR(Z, value, Instance); \
3287 if ((index >= 0) && (index < array.Length())) { \
3288 array.SetAt(index, value_obj); \
3289 return Api::Success(); \
3291 return Api::NewError("Invalid index passed into set list element");
3300 if (obj.IsArray() && !Array::Cast(obj).
IsImmutable()) {
3302 }
else if (obj.IsGrowableObjectArray()) {
3304 }
else if (obj.IsError()) {
3314 if (!value_obj.
IsNull() && !value_obj.IsInstance()) {
3319 Instance::Cast(value_obj)));
3322 "Object does not implement the 'List' interface");
3329 const String& dotted_name,
3343 return ApiError::New(
message);
3360 return ApiError::New(
message);
3365 args.SetAt(0, exception);
3375 String::New(
"No Dart frames on stack, cannot throw exception"));
3376 return ApiError::New(
message);
3383 InstancePtr raw_exception = exception.
ptr();
3390 return ApiError::New(
message);
3394#define GET_LIST_ELEMENT_AS_BYTES(type, obj, native_array, offset, length) \
3395 const type& array = type::Cast(obj); \
3396 if (Utils::RangeCheck(offset, length, array.Length())) { \
3397 Object& element = Object::Handle(Z); \
3398 for (int i = 0; i < length; i++) { \
3399 element = array.At(offset + i); \
3400 if (!element.IsInteger()) { \
3401 return Api::NewHandle( \
3402 T, ThrowArgumentError("List contains non-int elements")); \
3404 const Integer& integer = Integer::Cast(element); \
3405 native_array[i] = static_cast<uint8_t>(integer.AsInt64Value() & 0xff); \
3406 ASSERT(integer.AsInt64Value() <= 0xff); \
3408 return Api::Success(); \
3410 return Api::NewError("Invalid length passed into access array elements");
3414 uint8_t* native_array,
3418 if (obj.IsTypedDataBase()) {
3423 memmove(native_array,
3427 return Api::NewError(
"Invalid length passed into access list elements");
3430 if (obj.IsArray()) {
3433 if (obj.IsGrowableObjectArray()) {
3437 if (obj.IsError()) {
3445 const int kNumArgs = 2;
3452 for (
int i = 0; i <
length; i++) {
3455 args.SetAt(1, intobj);
3460 if (!
result.IsInteger()) {
3462 "%s expects the argument 'list' to be "
3471 static_cast<uint8_t
>(integer_result.
AsInt64Value() & 0xff);
3476 "Object does not implement the 'List' interface");
3479#define SET_LIST_ELEMENT_AS_BYTES(type, obj, native_array, offset, length) \
3480 const type& array = type::Cast(obj); \
3481 Integer& integer = Integer::Handle(Z); \
3482 if (Utils::RangeCheck(offset, length, array.Length())) { \
3483 for (int i = 0; i < length; i++) { \
3484 integer = Integer::New(native_array[i]); \
3485 array.SetAt(offset + i, integer); \
3487 return Api::Success(); \
3489 return Api::NewError("Invalid length passed into set array elements");
3493 const uint8_t* native_array,
3497 if (obj.IsTypedDataBase()) {
3506 return Api::NewError(
"Invalid length passed into access list elements");
3509 if (obj.IsArray() && !Array::Cast(obj).
IsImmutable()) {
3514 if (obj.IsGrowableObjectArray()) {
3518 if (obj.IsError()) {
3526 const int kNumArgs = 3;
3533 for (
int i = 0; i <
length; i++) {
3536 args.SetAt(1, indexobj);
3537 args.SetAt(2, valueobj);
3547 "Object does not implement the 'List' interface");
3559 if (!(key_obj.IsInstance() || key_obj.
IsNull())) {
3563 Instance::Cast(key_obj)));
3575 if (!(key_obj.IsInstance() || key_obj.
IsNull())) {
3580 Instance::Cast(key_obj)));
3606 case kTypedDataInt8ArrayCid:
3607 case kTypedDataInt8ArrayViewCid:
3608 case kUnmodifiableTypedDataInt8ArrayViewCid:
3609 case kExternalTypedDataInt8ArrayCid:
3612 case kTypedDataUint8ArrayCid:
3613 case kTypedDataUint8ArrayViewCid:
3614 case kUnmodifiableTypedDataUint8ArrayViewCid:
3615 case kExternalTypedDataUint8ArrayCid:
3618 case kTypedDataUint8ClampedArrayCid:
3619 case kTypedDataUint8ClampedArrayViewCid:
3620 case kUnmodifiableTypedDataUint8ClampedArrayViewCid:
3621 case kExternalTypedDataUint8ClampedArrayCid:
3624 case kTypedDataInt16ArrayCid:
3625 case kTypedDataInt16ArrayViewCid:
3626 case kUnmodifiableTypedDataInt16ArrayViewCid:
3627 case kExternalTypedDataInt16ArrayCid:
3630 case kTypedDataUint16ArrayCid:
3631 case kTypedDataUint16ArrayViewCid:
3632 case kUnmodifiableTypedDataUint16ArrayViewCid:
3633 case kExternalTypedDataUint16ArrayCid:
3636 case kTypedDataInt32ArrayCid:
3637 case kTypedDataInt32ArrayViewCid:
3638 case kUnmodifiableTypedDataInt32ArrayViewCid:
3639 case kExternalTypedDataInt32ArrayCid:
3642 case kTypedDataUint32ArrayCid:
3643 case kTypedDataUint32ArrayViewCid:
3644 case kUnmodifiableTypedDataUint32ArrayViewCid:
3645 case kExternalTypedDataUint32ArrayCid:
3648 case kTypedDataInt64ArrayCid:
3649 case kTypedDataInt64ArrayViewCid:
3650 case kUnmodifiableTypedDataInt64ArrayViewCid:
3651 case kExternalTypedDataInt64ArrayCid:
3654 case kTypedDataUint64ArrayCid:
3655 case kTypedDataUint64ArrayViewCid:
3656 case kUnmodifiableTypedDataUint64ArrayViewCid:
3657 case kExternalTypedDataUint64ArrayCid:
3660 case kTypedDataFloat32ArrayCid:
3661 case kTypedDataFloat32ArrayViewCid:
3662 case kUnmodifiableTypedDataFloat32ArrayViewCid:
3663 case kExternalTypedDataFloat32ArrayCid:
3666 case kTypedDataFloat64ArrayCid:
3667 case kTypedDataFloat64ArrayViewCid:
3668 case kUnmodifiableTypedDataFloat64ArrayViewCid:
3669 case kExternalTypedDataFloat64ArrayCid:
3672 case kTypedDataInt32x4ArrayCid:
3673 case kTypedDataInt32x4ArrayViewCid:
3674 case kUnmodifiableTypedDataInt32x4ArrayViewCid:
3675 case kExternalTypedDataInt32x4ArrayCid:
3678 case kTypedDataFloat32x4ArrayCid:
3679 case kTypedDataFloat32x4ArrayViewCid:
3680 case kUnmodifiableTypedDataFloat32x4ArrayViewCid:
3681 case kExternalTypedDataFloat32x4ArrayCid:
3684 case kTypedDataFloat64x2ArrayCid:
3685 case kTypedDataFloat64x2ArrayViewCid:
3686 case kUnmodifiableTypedDataFloat64x2ArrayViewCid:
3687 case kExternalTypedDataFloat64x2ArrayCid:
3722 const auto& view_obj = Api::UnwrapTypedDataViewHandle(zone,
object);
3723 ASSERT(!view_obj.IsNull());
3750 intptr_t external_allocation_size,
3752 bool unmodifiable) {
3778 intptr_t external_allocation_size,
3780 bool unmodifiable) {
3783 thread, kExternalTypedDataUint8ArrayCid,
data,
length, peer,
3784 external_allocation_size,
callback,
false);
3789 Api::UnwrapExternalTypedDataHandle(zone, ext_data);
3835 return Api::NewError(
"%s expects argument 'type' to be of 'TypedData'",
3847 intptr_t external_allocation_size,
3849 bool unmodifiable) {
3858 external_allocation_size,
callback,
3862 length, peer, external_allocation_size,
3866 length, peer, external_allocation_size,
3870 data,
length, peer, external_allocation_size,
3874 length, peer, external_allocation_size,
3878 length, peer, external_allocation_size,
3882 length, peer, external_allocation_size,
3886 length, peer, external_allocation_size,
3890 length, peer, external_allocation_size,
3894 length, peer, external_allocation_size,
3898 length, peer, external_allocation_size,
3902 length, peer, external_allocation_size,
3906 length, peer, external_allocation_size,
3910 length, peer, external_allocation_size,
3914 length, peer, external_allocation_size,
3918 "%s expects argument 'type' to be of"
3919 " 'external TypedData'",
3938 intptr_t external_allocation_size,
3949 intptr_t external_allocation_size,
3952 type,
const_cast<void*
>(
data),
length, peer, external_allocation_size,
3958 const String& constructor_name,
3959 intptr_t num_args) {
3979 Symbols::_ByteBufferDot_New(), 1);
3988 args.SetAt(0, Object::null_type_arguments());
4002 : size_in_bytes_(size_in_bytes), data_(
data), data_copy_(nullptr) {
4004 data_copy_ =
malloc(size_in_bytes_);
4005 memmove(data_copy_, data_, size_in_bytes_);
4010 void*
GetData()
const {
return data_copy_ !=
nullptr ? data_copy_ : data_; }
4014 if (data_copy_ !=
nullptr) {
4015 memmove(data_, data_copy_, size_in_bytes_);
4016 memset(data_copy_, kZapReleasedByte, size_in_bytes_);
4022 static constexpr uint8_t kZapReleasedByte = 0xda;
4023 intptr_t size_in_bytes_;
4042 if (
type ==
nullptr) {
4045 if (
data ==
nullptr) {
4048 if (len ==
nullptr) {
4054 intptr_t size_in_bytes = 0;
4055 void* data_tmp =
nullptr;
4056 bool external =
false;
4057 T->IncrementNoSafepointScopeDepth();
4061 Api::UnwrapExternalTypedDataHandle(
Z,
object);
4068 const TypedData& obj = Api::UnwrapTypedDataHandle(
Z,
object);
4076 const auto& view_obj = Api::UnwrapTypedDataViewHandle(
Z,
object);
4077 ASSERT(!view_obj.IsNull());
4079 val = view_obj.length();
4082 val = view_obj.offset_in_bytes();
4083 intptr_t offset_in_bytes = val.
Value();
4086 const TypedData& data_obj = TypedData::Cast(obj);
4087 data_tmp = data_obj.
DataAddr(offset_in_bytes);
4091 data_tmp = data_obj.
DataAddr(offset_in_bytes);
4095 if (FLAG_verify_acquired_data) {
4098 bool sweep_in_progress;
4100 PageSpace* old_space =
T->heap()->old_space();
4105 if (!sweep_in_progress) {
4107 ASSERT(!
T->heap()->Contains(
reinterpret_cast<uword>(data_tmp)));
4109 ASSERT(
T->heap()->Contains(
reinterpret_cast<uword>(data_tmp)));
4115 intptr_t current =
table->GetValue(obj.
ptr());
4117 return Api::NewError(
"Data was already acquired for this object.");
4123 table->SetValue(obj.
ptr(),
reinterpret_cast<intptr_t
>(ad));
4140 if (FLAG_verify_acquired_data) {
4143 intptr_t current =
table->GetValue(obj.
ptr());
4145 return Api::NewError(
"Data was not acquired for this object.");
4151 T->DecrementNoSafepointScopeDepth();
4176 const String& constr_name,
4183 if (constructor.
IsNull() ||
4193 "%s: could not find factory '%s' in class '%s'.", current_func,
4195 return ApiError::New(
message);
4199 current_func, constr_name.
ToCString()));
4200 return ApiError::New(
message);
4203 const int kTypeArgsLen = 0;
4204 const int extra_args = 1;
4207 0, &error_message)) {
4209 "%s: wrong argument count for "
4210 "constructor '%s': %s.",
4212 return ApiError::New(
message);
4216 return constructor.
ptr();
4221 int number_of_arguments,
4227 if (number_of_arguments < 0) {
4229 "%s expects argument 'number_of_arguments' to be non-negative.",
4235 if (unchecked_type.
IsNull() || !unchecked_type.IsType()) {
4239 type_obj ^= unchecked_type.
ptr();
4242 "%s expects argument 'type' to be a fully resolved type.",
4258 }
else if (
result.IsString()) {
4268 constr_name, number_of_arguments);
4290 intptr_t arg_index = 0;
4296 if (!type_arguments.
IsNull()) {
4302 args.SetAt(arg_index++, new_object);
4305 args.SetAt(arg_index++, type_arguments);
4308 for (
int i = 0; i < number_of_arguments; i++) {
4310 if (!argument.
IsNull() && !argument.IsInstance()) {
4311 if (argument.IsError()) {
4315 "%s expects arguments[%d] to be an Instance handle.",
CURRENT_FUNC,
4319 args.SetAt(arg_index++, argument);
4322 const int kTypeArgsLen = 0;
4328 args, args_descriptor, type_arguments, Object::empty_type_arguments());
4357 while (!iterate_cls.
IsNull()) {
4360 fields = iterate_cls.
fields();
4362 for (
int field_num = 0; field_num < fields.
Length(); field_num++) {
4363 field ^= fields.
At(field_num);
4381 const Type& type_obj = Api::UnwrapTypeHandle(
Z,
type);
4389 "%s expects argument 'type' to be a fully resolved type.",
4405 if (!type_arguments.
IsNull()) {
4413 intptr_t num_native_fields,
4414 const intptr_t* native_fields) {
4418 const Type& type_obj = Api::UnwrapTypeHandle(
Z,
type);
4423 if (native_fields ==
nullptr) {
4436 "%s: invalid number of native fields %" Pd " passed in, expected %d",
4440 instance.SetNativeFields(num_native_fields, native_fields);
4453 for (
int i = 0; i < num_args; i++) {
4455 if (!arg.
IsNull() && !arg.IsInstance()) {
4457 if (arg.IsError()) {
4461 "%s expects arguments[%d] to be an Instance handle.",
"Dart_Invoke",
4465 args->SetAt((i + extra_args), arg);
4472 int number_of_arguments,
4478 if (number_of_arguments < 0) {
4480 "%s expects argument 'number_of_arguments' to be non-negative.",
4502 if (constructor_name.
IsNull()) {
4505 strings.
SetAt(2, constructor_name);
4509 if (type_obj.IsType()) {
4510 type_arguments = Type::Cast(type_obj).GetInstanceTypeArguments(
T);
4514 const int kTypeArgsLen = 0;
4515 const int extra_args = 1;
4518 kTypeArgsLen, number_of_arguments + extra_args, 0,
nullptr)) {
4528 const int kTypeArgsLen = 0;
4533 args, args_descriptor, type_arguments);
4540 if (retval.IsError()) {
4548 return Api::NewError(
"%s expects argument 'name' to be a valid constructor.",
4554 int number_of_arguments,
4565 if (number_of_arguments < 0) {
4567 "%s expects argument 'number_of_arguments' to be non-negative.",
4571 if (obj.IsError()) {
4577 const Array& arg_names = Object::empty_array();
4578 const bool respect_reflectable =
false;
4579 const bool check_is_entrypoint = FLAG_verify_entry_points;
4581 if (!Type::Cast(obj).IsFinalized()) {
4583 "%s expects argument 'target' to be a fully resolved type.",
4600 check_is_entrypoint));
4601 }
else if (obj.
IsNull() || obj.IsInstance()) {
4616 check_is_entrypoint));
4617 }
else if (obj.IsLibrary()) {
4619 const Library& lib = Library::Cast(obj);
4623 return Api::NewError(
"%s expects library argument 'target' to be loaded.",
4639 check_is_entrypoint));
4642 "%s expects argument 'target' to be an object, type, or library.",
4648 int number_of_arguments,
4657 if (number_of_arguments < 0) {
4659 "%s expects argument 'number_of_arguments' to be non-negative.",
4666 args.SetAt(0, closure_obj);
4667 for (
int i = 0; i < number_of_arguments; i++) {
4669 if (!obj.
IsNull() && !obj.IsInstance()) {
4672 args.SetAt(i + 1, obj);
4685 if (field_name.
IsNull()) {
4689 const bool throw_nsm_if_absent =
true;
4690 const bool respect_reflectable =
false;
4691 const bool check_is_entrypoint = FLAG_verify_entry_points;
4694 if (!Type::Cast(obj).IsFinalized()) {
4696 "%s expects argument 'container' to be a fully resolved type.",
4706 respect_reflectable, check_is_entrypoint));
4707 }
else if (obj.
IsNull() || obj.IsInstance()) {
4716 instance.InvokeGetter(field_name, respect_reflectable,
4717 check_is_entrypoint));
4718 }
else if (obj.IsLibrary()) {
4719 const Library& lib = Library::Cast(obj);
4723 "%s expects library argument 'container' to be loaded.",
4731 respect_reflectable, check_is_entrypoint));
4732 }
else if (obj.IsError()) {
4736 "%s expects argument 'container' to be an object, type, or library.",
4750 if (field_name.
IsNull()) {
4756 if (!value_obj.
IsNull() && !value_obj.IsInstance()) {
4760 value_instance ^= value_obj.
ptr();
4763 const bool respect_reflectable =
false;
4764 const bool check_is_entrypoint = FLAG_verify_entry_points;
4767 if (!Type::Cast(obj).IsFinalized()) {
4769 "%s expects argument 'container' to be a fully resolved type.",
4781 T, cls.
InvokeSetter(field_name, value_instance, respect_reflectable,
4782 check_is_entrypoint));
4783 }
else if (obj.
IsNull() || obj.IsInstance()) {
4792 T,
instance.InvokeSetter(field_name, value_instance,
4793 respect_reflectable, check_is_entrypoint));
4794 }
else if (obj.IsLibrary()) {
4798 const Library& lib = Library::Cast(obj);
4802 "%s expects library argument 'container' to be loaded.",
4810 T, lib.
InvokeSetter(field_name, value_instance, respect_reflectable,
4811 check_is_entrypoint));
4812 }
else if (obj.IsError()) {
4816 "%s expects argument 'container' to be an object, type, or library.",
4839 return Api::NewError(
"No Dart frames on stack, cannot throw exception");
4846 InstancePtr raw_exception =
4852 return Api::NewError(
"Exception was not thrown, internal error");
4876 return Api::NewError(
"No Dart frames on stack, cannot throw exception");
4884 InstancePtr raw_exception =
4886 StackTracePtr raw_stacktrace =
4887 Api::UnwrapStackTraceHandle(zone, stacktrace).ptr();
4893 return Api::NewError(
"Exception was not re thrown, internal error");
4904 ReusableObjectHandleScope reused_obj_handle(thread);
4921 bool is_null =
false;
4923 ReusableObjectHandleScope reused_obj_handle(thread);
4927 if (
instance.IsValidNativeIndex(index)) {
4939 "%s: invalid index %d passed into access native instance field",
4951 if (!
instance.IsValidNativeIndex(index)) {
4953 "%s: invalid index %d passed into set native instance field",
4975 if (arg_values ==
nullptr) {
4978 for (
int i = 0; i < num_arguments; i++) {
4982 int arg_index = desc.index;
4983 ASSERT(arg_index >= 0 && arg_index < arguments->NativeArgCount());
4990 "%s: expects argument at index %d to be of"
5000 "%s: expects argument at index %d to be of"
5004 if (value < INT32_MIN || value > INT32_MAX) {
5006 "%s: argument value at index %d is out of range",
CURRENT_FUNC,
5017 "%s: expects argument at index %d to be of"
5021 if (value < 0 || value > UINT32_MAX) {
5023 "%s: argument value at index %d is out of range",
CURRENT_FUNC,
5034 "%s: expects argument at index %d to be of"
5046 "%s: expects argument at index %d to be of"
5058 "%s: expects argument at index %d to be of"
5069 "%s: expects argument at index %d to be of"
5106 "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
5122 intptr_t* field_values) {
5124 if ((arg_index < 0) || (arg_index >= arguments->
NativeArgCount())) {
5126 "%s: argument 'arg_index' out of range. Expected 0..%d but saw %d.",
5129 if (field_values ==
nullptr) {
5141 if (
value ==
nullptr) {
5148 "%s expects receiver argument to be non-null and of"
5161 "%s expects argument at %d to be of"
5174 "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
5179 "%s: expects argument at %d to be of"
5192 "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
5197 "%s: expects argument at %d to be of type Boolean.",
CURRENT_FUNC,
5209 "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
5214 "%s: expects argument at %d to be of"
5236 "Return value check failed: saw '%s' expected a dart Instance or "
5240 ASSERT(retval !=
nullptr);
5266 if (!FLAG_enable_mirrors &&
name.Equals(Symbols::DartLibraryMirrors())) {
5274 if (
name.Equals(Symbols::DartVMProduct())) {
5282 if (
name.Equals(Symbols::DartDeveloperTimeline())) {
5283#ifdef SUPPORT_TIMELINE
5290 const String& prefix = Symbols::DartLibrary();
5291 if (
name.StartsWith(prefix)) {
5292 const String& library_name =
5296 if (!library_name.
IsNull() && library_name.
CharAt(0) !=
'_') {
5297 const String& dart_library_name =
5315StringPtr Api::CallEnvironmentCallback(
Thread* thread,
const String&
name) {
5319 Scope api_scope(thread);
5326 const Object& response =
5328 if (response.IsString()) {
5329 return String::Cast(response).ptr();
5330 }
else if (response.IsError()) {
5333 }
else if (!response.IsNull()) {
5408 const char* resolved_uri;
5426#if defined(DART_PRECOMPILED_RUNTIME)
5437 return Api::NewError(
"%s: A script has already been loaded from '%s'.",
5445 kExternalTypedDataUint8ArrayCid,
const_cast<uint8_t*
>(
buffer),
5448 const char*
error =
nullptr;
5449 std::unique_ptr<kernel::Program> program =
5450 kernel::Program::ReadFromTypedData(td, &
error);
5451 if (program ==
nullptr) {
5457 if (tmp.IsError()) {
5462 IG->source()->script_kernel_buffer =
buffer;
5469 "Invoked Dart programs must have a 'main' function defined:\n"
5470 "https://dart.dev/guides/language/"
5471 "language-tour#a-basic-dart-program");
5473 library ^= tmp.
ptr();
5474 IG->object_store()->set_root_library(library);
5491 if (obj.
IsNull() || obj.IsLibrary()) {
5494 T->isolate_group()->object_store()->set_root_library(lib);
5503 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5515 return Api::NewError(
"Class '%s' not found in library '%s'.",
5525 intptr_t number_of_type_arguments,
5530 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5535 return Api::NewError(
"%s expects library argument 'library' to be loaded.",
5545 return Api::NewError(
"Type '%s' not found in library '%s'.",
5553 if (number_of_type_arguments != 0) {
5555 "Invalid number of type arguments specified, "
5556 "got %" Pd " expected 0",
5557 number_of_type_arguments);
5564 if (number_of_type_arguments > 0) {
5565 if (type_arguments ==
nullptr) {
5568 if (num_expected_type_arguments != number_of_type_arguments) {
5570 "Invalid number of type arguments specified, "
5571 "got %" Pd " expected %" Pd,
5572 number_of_type_arguments, num_expected_type_arguments);
5574 const Array& array = Api::UnwrapArrayHandle(
Z, *type_arguments);
5578 if (array.
Length() != num_expected_type_arguments) {
5580 "Invalid type arguments specified, expected an "
5581 "array of len %" Pd " but got an array of len %" Pd,
5582 number_of_type_arguments, array.
Length());
5587 for (intptr_t i = 0; i < number_of_type_arguments; i++) {
5588 type_arg ^= array.
At(i);
5602 intptr_t number_of_type_arguments,
5605 "Cannot use legacy types with --sound-null-safety enabled. "
5606 "Use Dart_GetNullableType or Dart_GetNonNullableType instead.");
5611 intptr_t number_of_type_arguments,
5620 intptr_t number_of_type_arguments,
5628 const Type& ty = Api::UnwrapTypeHandle(
Z,
type);
5650 const Type& ty = Api::UnwrapTypeHandle(
Z,
type);
5673 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5684 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5691 ASSERT(!script.IsNull());
5699 auto IG =
T->isolate_group();
5703 int num_libs = libs.Length();
5708 for (
int i = 0; i < num_libs; i++) {
5711 library_list.
SetAt(i, lib);
5736 const Library& lib = Api::UnwrapLibraryHandle(
Z, library_in);
5749#if !defined(DART_PRECOMPILED_RUNTIME)
5751 const char*
error =
nullptr;
5752 std::unique_ptr<kernel::Program> program =
5753 kernel::Program::ReadFromTypedData(td, &
error);
5754 if (program ==
nullptr) {
5762 source->add_loaded_blob(
Z, td);
5770#if defined(DART_PRECOMPILED_RUNTIME)
5782 kExternalTypedDataUint8ArrayCid,
const_cast<uint8_t*
>(
buffer),
5789#if defined(DART_PRECOMPILED_RUNTIME)
5794 Api::UnwrapExternalTypedDataHandle(
Z, kernel_buffer);
5816#if !defined(PRODUCT)
5822 I->debugger()->NotifyDoneLoading();
5829 if (
I->group()->ContainsOnlyOneIsolate()) {
5830 I->group()->heap()->old_space()->EvaluateAfterLoading();
5833#if !defined(DART_PRECOMPILED_RUNTIME)
5834 if (FLAG_enable_mirrors) {
5837 const Field& dirty_bit =
5850 const uint8_t* snapshot_data,
5851 const uint8_t* snapshot_instructions,
5852 const char* error_message,
5853 bool transient_error) {
5856 auto IG =
T->isolate_group();
5859 const Array& loading_units =
5862 (loading_unit_id >= loading_units.
Length())) {
5866 unit ^= loading_units.
At(loading_unit_id);
5877#if defined(SUPPORT_TIMELINE)
5878 TimelineBeginEndScope tbes(
T, Timeline::GetIsolateStream(),
5879 "ReadUnitSnapshot");
5882 if (snapshot ==
nullptr) {
5887 "Incompatible snapshot kinds: vm '%s', isolate '%s'",
5895 if (!
error.IsNull()) {
5905 const uint8_t* snapshot_data,
5906 const uint8_t* snapshot_instructions) {
5908 snapshot_instructions,
nullptr,
false);
5913 const char* error_message,
5916 error_message, transient);
5924 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5936 if (resolver ==
nullptr) {
5939 *resolver =
nullptr;
5941 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5951 if (resolver ==
nullptr) {
5954 *resolver =
nullptr;
5956 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5968 const Library& lib = Api::UnwrapLibraryHandle(
Z, library);
5979 if (peer ==
nullptr) {
5986 Object& obj = thread->ObjectHandle();
5988 if (obj.
IsNull() || obj.IsNumber() || obj.IsBool()) {
5990 "%s: argument 'object' cannot be a subtype of Null, num, or bool";
6006 Object& obj = thread->ObjectHandle();
6008 if (obj.
IsNull() || obj.IsNumber() || obj.IsBool()) {
6010 "%s: argument 'object' cannot be a subtype of Null, num, or bool";
6024#if defined(DART_PRECOMPILED_RUNTIME)
6028 return iso->is_kernel_isolate();
6033#if defined(DART_PRECOMPILED_RUNTIME)
6041#if defined(DART_PRECOMPILED_RUNTIME)
6050 const uint8_t* platform_kernel,
6051 intptr_t platform_kernel_size,
6052 bool incremental_compile,
6055 const char* package_config,
6060#if defined(DART_PRECOMPILED_RUNTIME)
6065 script_uri, platform_kernel, platform_kernel_size, 0,
nullptr,
6066 incremental_compile, for_snapshot, embed_sources, package_config,
nullptr,
6067 nullptr, verbosity);
6068 if (incremental_compile) {
6075 "An error occurred in the CFE while acking the most recent"
6076 " compilation results: %s",
6086#if defined(DART_PRECOMPILED_RUNTIME)
6096 const uint8_t* platform_kernel,
6097 const intptr_t platform_kernel_size) {
6098#if !defined(PRODUCT)
6100 platform_kernel_size);
6105 const char* package_config,
6106 const char* original_working_directory,
6107 const uint8_t* snapshot_data,
6108 const uint8_t* snapshot_instructions,
6109 const uint8_t* kernel_buffer,
6110 intptr_t kernel_buffer_size) {
6118 return iso->is_service_isolate();
6125#if !defined(PRODUCT)
6134#if !defined(PRODUCT)
6141#if !defined(PRODUCT)
6152 if (listen_callback !=
nullptr) {
6155 "Dart_SetServiceStreamCallbacks "
6156 "permits only one listen callback to be registered, please "
6157 "remove the existing callback and then add this callback");
6162 "Dart_SetServiceStreamCallbacks "
6163 "expects 'listen_callback' to be present in the callback set.");
6166 if (cancel_callback !=
nullptr) {
6169 "Dart_SetServiceStreamCallbacks "
6170 "permits only one cancel callback to be registered, please "
6171 "remove the existing callback and then add this callback");
6176 "Dart_SetServiceStreamCallbacks "
6177 "expects 'cancel_callback' to be present in the callback set.");
6186 const char* event_kind,
6187 const uint8_t* bytes,
6188 intptr_t bytes_length) {
6189#if !defined(PRODUCT)
6190 if (stream_id ==
nullptr) {
6192 "Dart_ServiceSendDataEvent expects argument 'stream_id' to be "
6195 if (event_kind ==
nullptr) {
6197 "Dart_ServiceSendDataEvent expects argument 'event_kind' to be "
6200 if (bytes ==
nullptr) {
6202 "Dart_ServiceSendDataEvent expects argument 'bytes' to be non-null.");
6204 if (bytes_length < 0) {
6206 "Dart_ServiceSendDataEvent expects argument 'bytes_length' to be >= "
6210 stream_id, event_kind, bytes, bytes_length);
6222#if !defined(PRODUCT)
6223#if !defined(DART_PRECOMPILED_RUNTIME)
6224 if (file_modified_callback !=
nullptr) {
6227 "Dart_SetFileModifiedCallback permits only one callback to be"
6228 " registered, please remove the existing callback and then add"
6234 "Dart_SetFileModifiedCallback expects 'file_modified_callback' to"
6235 " be set before it is cleared.");
6245#if defined(PRODUCT) || defined(DART_PRECOMPILED_RUNTIME)
6256#if defined(SUPPORT_TIMELINE)
6258 if (categories !=
nullptr) {
6283 int64_t timestamp1_or_id,
6284 intptr_t flow_id_count,
6285 const int64_t* flow_ids,
6288 const char** argument_names,
6289 const char** argument_values) {
6290#if defined(SUPPORT_TIMELINE)
6301 ASSERT(stream !=
nullptr);
6302 TimelineEvent*
event = stream->StartEvent();
6303 if (
event !=
nullptr) {
6306 event->Begin(label, timestamp1_or_id, timestamp0);
6309 event->End(label, timestamp1_or_id, timestamp0);
6312 event->Instant(label, timestamp0);
6315 event->Duration(label, timestamp0, timestamp1_or_id);
6318 event->AsyncBegin(label, timestamp1_or_id, timestamp0);
6321 event->AsyncEnd(label, timestamp1_or_id, timestamp0);
6324 event->AsyncInstant(label, timestamp1_or_id, timestamp0);
6327 event->Counter(label, timestamp0);
6330 event->FlowBegin(label, timestamp1_or_id, timestamp0);
6333 event->FlowStep(label, timestamp1_or_id, timestamp0);
6336 event->FlowEnd(label, timestamp1_or_id, timestamp0);
6339 FATAL(
"Unknown Dart_Timeline_Event_Type");
6341 if (flow_id_count > 0 && flow_ids !=
nullptr) {
6342 std::unique_ptr<const int64_t[]> flow_ids_copy;
6343 int64_t* flow_ids_internal =
new int64_t[flow_id_count];
6344 for (intptr_t i = 0; i < flow_id_count; ++i) {
6345 flow_ids_internal[i] = flow_ids[i];
6347 flow_ids_copy = std::unique_ptr<const int64_t[]>(flow_ids_internal);
6348 event->SetFlowIds(flow_id_count, flow_ids_copy);
6352 event->CopyArgument(i, argument_names[i], argument_values[i]);
6362#if defined(SUPPORT_TIMELINE)
6369 if (thread ==
nullptr) {
6377#if defined(DART_PRECOMPILED_RUNTIME)
6398#if defined(TARGET_ARCH_IA32)
6399 return Api::NewError(
"AOT compilation is not supported on IA32.");
6400#elif !defined(DART_PRECOMPILER)
6402 "This VM was built without support for AOT compilation.");
6406 if (!FLAG_precompiled_mode) {
6407 return Api::NewError(
"Flag --precompilation was not specified.");
6422#if !defined(TARGET_ARCH_IA32) && defined(DART_PRECOMPILER)
6423static constexpr intptr_t kAssemblyInitialSize = 512 *
KB;
6425static constexpr intptr_t kInitialDebugSize = 1 *
MB;
6427static void CreateAppAOTSnapshot(
6429 void* callback_data,
6432 void* debug_callback_data,
6433 GrowableArray<LoadingUnitSerializationData*>* units,
6434 LoadingUnitSerializationData* unit,
6435 uint32_t program_hash) {
6438 NOT_IN_PRODUCT(TimelineBeginEndScope tbes2(
T, Timeline::GetIsolateStream(),
6439 "WriteAppAOTSnapshot"));
6442 ZoneWriteStream vm_snapshot_instructions(
T->zone(),
kInitialSize);
6443 ZoneWriteStream isolate_snapshot_data(
T->zone(),
6445 ZoneWriteStream isolate_snapshot_instructions(
T->zone(),
kInitialSize);
6447 const bool generate_debug = debug_callback_data !=
nullptr;
6449 auto*
const deobfuscation_trie =
6450 (strip && !generate_debug) ?
nullptr
6451 : ImageWriter::CreateReverseObfuscationTrie(
T);
6455 StreamingWriteStream debug_stream(generate_debug ? kInitialDebugSize : 0,
6458 auto const dwarf = strip ? nullptr :
new (
Z) Dwarf(
Z, deobfuscation_trie);
6459 auto const elf =
new (
Z) Elf(
Z, &elf_stream, Elf::Type::Snapshot, dwarf);
6461 auto const debug_elf =
6463 ?
new (
Z) Elf(
Z, &debug_stream, Elf::Type::DebugInfo,
6464 strip ?
new (
Z) Dwarf(
Z, deobfuscation_trie) : dwarf)
6467 BlobImageWriter image_writer(
T, &vm_snapshot_instructions,
6468 &isolate_snapshot_instructions,
6469 deobfuscation_trie, debug_elf, elf);
6471 &isolate_snapshot_data, &image_writer,
6475 writer.WriteFullSnapshot(units);
6477 writer.WriteUnitSnapshot(units, unit, program_hash);
6481 if (debug_elf !=
nullptr) {
6482 debug_elf->Finalize();
6485 StreamingWriteStream assembly_stream(kAssemblyInitialSize,
callback,
6487 StreamingWriteStream debug_stream(generate_debug ? kInitialDebugSize : 0,
6490 auto const elf = generate_debug
6491 ?
new (
Z) Elf(
Z, &debug_stream, Elf::Type::DebugInfo,
6492 new (
Z) Dwarf(
Z, deobfuscation_trie))
6495 AssemblyImageWriter image_writer(
T, &assembly_stream, deobfuscation_trie,
6498 &isolate_snapshot_data, &image_writer,
6502 writer.WriteFullSnapshot(units);
6504 writer.WriteUnitSnapshot(units, unit, program_hash);
6506 image_writer.Finalize();
6511 void* next_callback_data,
6517 ProgramVisitor::AssignUnits(
T);
6519 const Array& loading_units =
6520 Array::Handle(
T->isolate_group()->object_store()->loading_units());
6521 const uint32_t program_hash = ProgramVisitor::Hash(
T);
6523 GrowableArray<LoadingUnitSerializationData*>
data;
6524 data.SetLength(loading_units.Length());
6529 for (intptr_t
id = 1;
id < loading_units.Length();
id++) {
6530 loading_unit ^= loading_units.At(
id);
6531 parent = loading_unit.parent();
6532 LoadingUnitSerializationData* parent_data =
6533 parent.IsNull() ? nullptr :
data[parent.id()];
6534 data[
id] =
new LoadingUnitSerializationData(
id, parent_data);
6537 for (intptr_t
id = 1;
id < loading_units.Length();
id++) {
6538 void* write_callback_data =
nullptr;
6539 void* write_debug_callback_data =
nullptr;
6541 TransitionVMToNative transition(
T);
6542 next_callback(next_callback_data,
id, &write_callback_data,
6543 &write_debug_callback_data);
6545 CreateAppAOTSnapshot(write_callback, write_callback_data, strip, as_elf,
6546 write_debug_callback_data, &
data,
data[
id],
6549 TransitionVMToNative transition(
T);
6550 close_callback(write_callback_data);
6551 if (write_debug_callback_data !=
nullptr) {
6552 close_callback(write_debug_callback_data);
6561 void* callback_data,
6563 void* debug_callback_data) {
6564#if defined(TARGET_ARCH_IA32)
6565 return Api::NewError(
"AOT compilation is not supported on IA32.");
6566#elif defined(DART_TARGET_OS_WINDOWS)
6567 return Api::NewError(
"Assembly generation is not implemented for Windows.");
6568#elif !defined(DART_PRECOMPILER)
6570 "This VM was built without support for AOT compilation.");
6577 T->isolate_group()->object_store()->set_loading_units(Object::null_array());
6579 CreateAppAOTSnapshot(
callback, callback_data, strip,
false,
6580 debug_callback_data,
nullptr,
nullptr, 0);
6588 void* next_callback_data,
6592#if defined(TARGET_ARCH_IA32)
6593 return Api::NewError(
"AOT compilation is not supported on IA32.");
6594#elif defined(DART_TARGET_OS_WINDOWS)
6595 return Api::NewError(
"Assembly generation is not implemented for Windows.");
6596#elif !defined(DART_PRECOMPILER)
6598 "This VM was built without support for AOT compilation.");
6606 Split(next_callback, next_callback_data, strip,
false,
6607 write_callback, close_callback);
6615 void* callback_data) {
6616#if defined(TARGET_ARCH_IA32)
6617 return Api::NewError(
"AOT compilation is not supported on IA32.");
6618#elif defined(DART_TARGET_OS_WINDOWS)
6619 return Api::NewError(
"Assembly generation is not implemented for Windows.");
6620#elif !defined(DART_PRECOMPILER)
6622 "This VM was built without support for AOT compilation.");
6631 AssemblyImageWriter image_writer(
T, &assembly_stream);
6634 &image_writer,
nullptr);
6644 void* callback_data,
6646 void* debug_callback_data) {
6647#if defined(TARGET_ARCH_IA32)
6648 return Api::NewError(
"AOT compilation is not supported on IA32.");
6649#elif !defined(DART_PRECOMPILER)
6651 "This VM was built without support for AOT compilation.");
6658 T->isolate_group()->object_store()->set_loading_units(Object::null_array());
6660 CreateAppAOTSnapshot(
callback, callback_data, strip,
true,
6661 debug_callback_data,
nullptr,
nullptr, 0);
6669 void* next_callback_data,
6673#if defined(TARGET_ARCH_IA32)
6674 return Api::NewError(
"AOT compilation is not supported on IA32.");
6675#elif !defined(DART_PRECOMPILER)
6677 "This VM was built without support for AOT compilation.");
6685 Split(next_callback, next_callback_data, strip,
true,
6686 write_callback, close_callback);
6693#if defined(TARGET_ARCH_IA32)
6694 return Api::NewError(
"AOT compilation is not supported on IA32.");
6695#elif !defined(DART_PRECOMPILER)
6697 "This VM was built without support for AOT compilation.");
6702 const Array& loading_units =
6703 Array::Handle(
Z,
T->isolate_group()->object_store()->loading_unit_uris());
6704 if (loading_unit_id >= 0 && loading_unit_id < loading_units.
Length()) {
6711#if (!defined(TARGET_ARCH_IA32) && !defined(DART_PRECOMPILED_RUNTIME))
6720 const String& execute_match_name =
6722 const String& execute_match_sticky_name =
6726 const Class& reg_exp_class =
6739 code.DisableDartCode();
6750 code.DisableDartCode();
6759#if !defined(TARGET_ARCH_IA32) && !defined(DART_PRECOMPILED_RUNTIME)
6761 auto group = main_isolate->
group();
6763 bool non_main_isolates_alive =
false;
6766 group->ForEachIsolate(
6768 if (isolate != main_isolate) {
6770 non_main_isolates_alive =
true;
6774 if (!non_main_isolates_alive) {
6785 intptr_t* isolate_snapshot_data_size,
6786 uint8_t** isolate_snapshot_instructions_buffer,
6787 intptr_t* isolate_snapshot_instructions_size) {
6788#if defined(TARGET_ARCH_IA32)
6789 return Api::NewError(
"Snapshots with code are not supported on IA32.");
6790#elif defined(DART_PRECOMPILED_RUNTIME)
6791 return Api::NewError(
"JIT app snapshots cannot be taken from an AOT runtime");
6795 auto I =
T->isolate();
6796 auto IG =
T->isolate_group();
6799 CHECK_NULL(isolate_snapshot_instructions_buffer);
6800 CHECK_NULL(isolate_snapshot_instructions_size);
6816 if (FLAG_dump_tables) {
6829 &isolate_snapshot_instructions);
6831 nullptr, &image_writer);
6834 *isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();
6835 *isolate_snapshot_data_size = isolate_snapshot_data.bytes_written();
6836 *isolate_snapshot_instructions_buffer =
6837 isolate_snapshot_instructions.buffer();
6838 *isolate_snapshot_instructions_size =
6839 isolate_snapshot_instructions.bytes_written();
6846 intptr_t* buffer_length) {
6847#if defined(DART_PRECOMPILED_RUNTIME)
6848 return Api::NewError(
"No obfuscation map to save on an AOT runtime.");
6849#elif !defined(DART_PRECOMPILER)
6850 return Api::NewError(
"Obfuscation is only supported for AOT compiler.");
6859 if (buffer_length ==
nullptr) {
6864 const intptr_t kInitialBufferSize = 1 *
MB;
6869 for (intptr_t i = 0; isolate_group->
obfuscation_map()[i] !=
nullptr; i++) {
6880 *buffer_length = text_buffer.
length();
6881 *
reinterpret_cast<char**
>(
buffer) = text_buffer.
buffer();
6887#if defined(DART_PRECOMPILED_RUNTIME)
6895#if !defined(PRODUCT) || defined(DART_PRECOMPILER)
6924 if (label ==
nullptr) {
6926 "Dart_NewUserTag expects argument 'label' to be non-null");
6936 const UserTag& tag = Api::UnwrapUserTagHandle(
Z, user_tag);
6945 const UserTag& tag = Api::UnwrapUserTagHandle(
Z, user_tag);
6956#if defined(DART_ENABLE_HEAP_SNAPSHOT_WRITER)
6958 CallbackHeapSnapshotWriter callback_writer(
T,
write, context);
6959 HeapSnapshotWriter writer(
T, &callback_writer);
6963 return Utils::StrDup(
"VM is built without the heap snapshot writer.");
static uint32_t buffer_size(uint32_t offset, uint32_t maxAlignment)
#define CLASS_LIST_FOR_HANDLES(V)
Nullability nullability() const
virtual ClassPtr type_class() const
AcquiredData(void *data, intptr_t size_in_bytes, bool copy)
LocalHandles * local_handles()
ApiLocalScope * previous() const
static ApiNativeScope * Current()
bool IsActivePersistentHandle(Dart_PersistentHandle object)
bool IsValidWeakPersistentHandle(Dart_WeakPersistentHandle object)
bool IsActiveWeakPersistentHandle(Dart_WeakPersistentHandle object)
static Dart_Handle Success()
static void SetDoubleReturnValue(NativeArguments *args, double retval)
static bool IsInstance(Dart_Handle handle)
static Dart_Handle NewHandle(Thread *thread, ObjectPtr raw)
static void SetReturnValue(NativeArguments *args, Dart_Handle retval)
static bool GetNativeFieldsOfArgument(NativeArguments *args, int arg_index, int num_fields, intptr_t *field_values)
static Dart_Isolate CastIsolate(Isolate *isolate)
static ApiLocalScope * TopScope(Thread *thread)
static ObjectPtr UnwrapHandle(Dart_Handle object)
static bool GetNativeBooleanArgument(NativeArguments *args, int arg_index, bool *value)
static StringPtr GetEnvironmentValue(Thread *thread, const String &name)
static Dart_Handle False()
static intptr_t ClassId(Dart_Handle handle)
static Dart_Handle static Dart_Handle NewArgumentError(const char *format,...) PRINTF_ATTRIBUTE(1
static Dart_IsolateGroup CastIsolateGroup(IsolateGroup *isolate_group)
static bool StringGetPeerHelper(NativeArguments *args, int arg_index, void **peer)
static Dart_Handle static Dart_Handle static Dart_Handle Null()
static void InitHandles()
static bool GetNativeDoubleArgument(NativeArguments *args, int arg_index, double *value)
static const Instance & UnwrapInstanceHandle(const ReusableObjectHandleScope &reused, Dart_Handle object)
static bool IsFfiEnabled()
static Dart_Handle EmptyString()
static bool IsProtectedHandle(Dart_Handle object)
static bool GetNativeIntegerArgument(NativeArguments *args, int arg_index, int64_t *value)
static const String & UnwrapStringHandle(const ReusableObjectHandleScope &reused, Dart_Handle object)
static void SetWeakHandleReturnValue(NativeArguments *args, Dart_WeakPersistentHandle retval)
static void SetSmiReturnValue(NativeArguments *args, intptr_t retval)
static Dart_Handle True()
static bool IsValid(Dart_Handle handle)
static intptr_t SmiValue(Dart_Handle handle)
static bool GetNativeReceiver(NativeArguments *args, intptr_t *value)
static bool IsSmi(Dart_Handle handle)
static void SetIntegerReturnValue(NativeArguments *args, int64_t retval)
static bool IsError(Dart_Handle handle)
static Dart_Handle NewError(const char *format,...) PRINTF_ATTRIBUTE(1
static Dart_Handle CheckAndFinalizePendingClasses(Thread *thread)
static ArrayPtr NewBoxed(intptr_t type_args_len, intptr_t num_arguments, const Array &optional_arguments_names, Heap::Space space=Heap::kOld)
static constexpr intptr_t kMaxElements
static ArrayPtr New(intptr_t len, Heap::Space space=Heap::kNew)
virtual void SetTypeArguments(const TypeArguments &value) const
ObjectPtr At(intptr_t index) const
void SetAt(intptr_t index, const Object &value) const
void AddEscapedString(const char *s)
static const Bool & False()
static const Bool & Get(bool value)
static const Bool & True()
static InstancePtr Data(const Instance &view_obj)
static AbstractTypePtr FinalizeType(const AbstractType &type, FinalizationKind finalization=kCanonicalize)
static bool ProcessPendingClasses()
static bool AllClassesFinalized()
static void ClearAllCode(bool including_nonchanging_cids=false)
static void SortClasses()
ClassPtr At(intptr_t cid) const
FunctionPtr LookupFunctionAllowPrivate(const String &name) const
ObjectPtr InvokeSetter(const String &selector, const Instance &argument, bool respect_reflectable=true, bool check_is_entrypoint=false) const
LibraryPtr library() const
ObjectPtr Invoke(const String &selector, const Array &arguments, const Array &argument_names, bool respect_reflectable=true, bool check_is_entrypoint=false) const
ObjectPtr InvokeGetter(const String &selector, bool throw_nsm_if_absent, bool respect_reflectable=true, bool check_is_entrypoint=false) const
void set_is_fields_marked_nullable() const
intptr_t NumTypeArguments() const
static bool IsSubtypeOf(const Class &cls, const TypeArguments &type_arguments, Nullability nullability, const AbstractType &other, Heap::Space space, FunctionTypeMapping *function_type_equivalence=nullptr)
uint16_t num_native_fields() const
bool IsDynamicClass() const
FunctionPtr LookupStaticFunctionAllowPrivate(const String &name) const
ErrorPtr EnsureIsFinalized(Thread *thread) const
bool is_future_subtype() const
ErrorPtr EnsureIsAllocateFinalized(Thread *thread) const
bool is_fields_marked_nullable() const
ClassPtr SuperClass(ClassTable *class_table=nullptr) const
StringPtr UserVisibleName() const
bool IsNeverClass() const
bool is_allocated() const
DART_WARN_UNUSED_RESULT ErrorPtr VerifyEntryPoint() const
intptr_t NumTypeParameters(Thread *thread) const
bool is_finalized() const
void EnsureDeclarationLoaded() const
static ObjectPtr InvokeClosure(Thread *thread, const Array &arguments)
static ObjectPtr InvokeFunction(const Function &function, const Array &arguments)
static ObjectPtr InstanceCreate(const Library &library, const String &exception_name, const String &constructor_name, const Array &arguments)
static ObjectPtr Equals(const Instance &left, const Instance &right)
static ObjectPtr ToString(const Instance &receiver)
static ErrorPtr InitializeIsolateGroup(Thread *T, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
static bool IsReadOnlyHandle(uword address)
static void ShutdownIsolate(Thread *T)
static bool SetActiveApiCall()
static Isolate * vm_isolate()
static char * Init(const Dart_InitializeParams *params)
static Isolate * CreateIsolate(const char *name_prefix, const Dart_IsolateFlags &api_flags, IsolateGroup *isolate_group)
static bool IsReadOnlyApiHandle(Dart_Handle handle)
static void ResetActiveApiCall()
static Snapshot::Kind vm_snapshot_kind()
static void RunShutdownCallback()
static LocalHandle * AllocateReadOnlyApiHandle()
static ErrorPtr InitializeIsolate(Thread *T, bool is_first_isolate_in_group, void *isolate_data)
static void set_dwarf_stacktrace_footnote_callback(Dart_DwarfStackTraceFootnoteCallback cb)
static DoublePtr New(double d, Heap::Space space=Heap::kNew)
static DART_NORETURN void Throw(Thread *thread, const Instance &exception)
static DART_NORETURN void ThrowArgumentError(const Instance &arg)
static DART_NORETURN void ReThrow(Thread *thread, const Instance &exception, const Instance &stacktrace, bool bypass_debugger=false)
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 bool IsExternalTypedData(const Instance &obj)
static intptr_t MaxElements(intptr_t class_id)
void SetStaticValue(const Object &value) const
void RecordStore(const Object &value) const
static FinalizablePersistentHandle * New(IsolateGroup *isolate_group, const Object &object, void *peer, Dart_HandleFinalizer callback, intptr_t external_size, bool auto_delete)
Dart_HandleFinalizer callback() const
Dart_FinalizableHandle ApiFinalizableHandle()
bool IsFinalizedNotFreed() const
static intptr_t ptr_offset()
Dart_WeakPersistentHandle ApiWeakPersistentHandle()
static FinalizablePersistentHandle * Cast(Dart_WeakPersistentHandle handle)
static char * ProcessCommandLineFlags(int argc, const char **argv)
static bool IsSet(const char *name)
ApiErrorPtr ReadUnitSnapshot(const LoadingUnit &unit)
intptr_t VmIsolateSnapshotSize() const
void WriteFullSnapshot(GrowableArray< LoadingUnitSerializationData * > *data=nullptr)
intptr_t IsolateSnapshotSize() const
static constexpr intptr_t kInitialSize
CodePtr CurrentCode() const
StringPtr UserVisibleName() const
ObjectPtr DoArgumentTypesMatch(const Array &args, const ArgumentsDescriptor &arg_names) const
bool IsImplicitClosureFunction() const
FunctionPtr parent_function() const
bool AreValidArgumentCounts(intptr_t num_type_arguments, intptr_t num_arguments, intptr_t num_named_arguments, String *error_message) const
DART_WARN_UNUSED_RESULT ErrorPtr VerifyCallEntryPoint() const
FunctionPtr ImplicitClosureFunction() const
bool IsNonImplicitClosureFunction() const
bool IsGenerativeConstructor() const
UntaggedFunction::Kind kind() const
ClosurePtr ImplicitStaticClosure() const
void ClearICDataArray() const
void IterateObjects(ObjectVisitor *visitor) const
static void SetSamplingCallback(Dart_HeapSamplingCreateCallback create_callback, Dart_HeapSamplingDeleteCallback delete_callback)
static void SetSamplingInterval(intptr_t bytes_interval)
static void Enable(bool enabled)
void * GetPeer(ObjectPtr raw_obj) const
void SetPeer(ObjectPtr raw_obj, void *peer)
void CollectAllGarbage(GCReason reason=GCReason::kFull, bool compact=false)
Space SpaceForExternal(intptr_t size) const
bool IsCallable(Function *function) const
virtual void SetTypeArguments(const TypeArguments &value) const
static InstancePtr New(const Class &cls, Heap::Space space=Heap::kNew)
static IntegerPtr New(const String &str, Heap::Space space=Heap::kNew)
const char * ToHexCString(Zone *zone) const
virtual bool IsNegative() const
static IntegerPtr NewFromUint64(uint64_t value, Heap::Space space=Heap::kNew)
virtual int64_t AsInt64Value() const
static bool IsValueInRange(uint64_t value)
static Dart_FileModifiedCallback file_modified_callback()
static void SetFileModifiedCallback(Dart_FileModifiedCallback callback)
const char ** obfuscation_map() const
void * embedder_data() const
ObjectStore * object_store() const
SafepointRwLock * program_lock()
static IsolateGroup * Current()
ClassTable * class_table() const
ApiState * api_state() const
void set_library_tag_handler(Dart_LibraryTagHandler handler)
static void RegisterIsolateGroup(IsolateGroup *isolate_group)
static void ForEach(std::function< void(IsolateGroup *)> action)
void set_deferred_load_handler(Dart_DeferredLoadHandler handler)
IsolateGroupSource * source() const
Thread * scheduled_mutator_thread() const
Dart_EnvironmentCallback environment_callback() const
ErrorPtr sticky_error() const
UserTagPtr current_tag() const
static Isolate * Current()
void set_on_shutdown_callback(Dart_IsolateShutdownCallback value)
static void KillIfExists(Isolate *isolate, LibMsgId msg_id)
UserTagPtr default_tag() const
MessageHandler * message_handler() const
static void FlagsInitialize(Dart_IsolateFlags *api_flags)
void set_on_cleanup_callback(Dart_IsolateCleanupCallback value)
bool HasPendingMessages()
void * init_callback_data() const
void set_environment_callback(Dart_EnvironmentCallback value)
IsolateGroup * group() const
void set_init_callback_data(void *value)
Dart_MessageNotifyCallback message_notify_callback() const
bool AllowClassFinalization()
void set_origin_id(Dart_Port id)
void set_message_notify_callback(Dart_MessageNotifyCallback value)
Dart_Port main_port() const
void SetStickyError(ErrorPtr sticky_error)
const char * name() const
static Dart_KernelCompilationResult ListDependencies()
static Dart_KernelCompilationResult CompileToKernel(const char *script_uri, const uint8_t *platform_kernel, intptr_t platform_kernel_size, int source_files_count=0, Dart_SourceFile source_files[]=nullptr, bool incremental_compile=true, bool for_snapshot=false, bool embed_sources=true, const char *package_config=nullptr, const char *multiroot_filepaths=nullptr, const char *multiroot_scheme=nullptr, Dart_KernelCompilationVerbosityLevel verbosity=Dart_KernelCompilationVerbosityLevel_All)
static Dart_KernelCompilationResult RejectCompilation()
static Dart_KernelCompilationResult AcceptCompilation()
static Dart_Port KernelPort()
static LibraryPtr CoreLibrary()
StringPtr PrivateName(const String &name) const
void set_native_entry_symbol_resolver(Dart_NativeEntrySymbol native_symbol_resolver) const
static LibraryPtr MirrorsLibrary()
static bool IsPrivate(const String &name)
ObjectPtr InvokeGetter(const String &selector, bool throw_nsm_if_absent, bool respect_reflectable=true, bool check_is_entrypoint=false) const
void set_native_entry_resolver(Dart_NativeEntryResolver value) const
ObjectPtr InvokeSetter(const String &selector, const Instance &argument, bool respect_reflectable=true, bool check_is_entrypoint=false) const
void set_ffi_native_resolver(Dart_FfiNativeResolver value) const
ClassPtr LookupClassAllowPrivate(const String &name) const
ObjectPtr Invoke(const String &selector, const Array &arguments, const Array &argument_names, bool respect_reflectable=true, bool check_is_entrypoint=false) const
FunctionPtr LookupFunctionAllowPrivate(const String &name) const
ClassPtr toplevel_class() const
Dart_NativeEntrySymbol native_entry_symbol_resolver() const
static LibraryPtr LookupLibrary(Thread *thread, const String &url)
Dart_NativeEntryResolver native_entry_resolver() const
FieldPtr LookupFieldAllowPrivate(const String &name) const
ObjectPtr CompleteLoad(const String &error_message, bool transient_error) const
static constexpr intptr_t kRootId
void set_ptr(ObjectPtr ptr)
static intptr_t ptr_offset()
void PausedOnStart(bool paused)
void PausedOnExit(bool paused)
bool is_paused_on_start() const
void set_should_pause_on_start(bool should_pause_on_start)
void set_should_pause_on_exit(bool should_pause_on_exit)
bool is_paused_on_exit() const
bool should_pause_on_start() const
bool should_pause_on_exit() const
Monitor::WaitResult Wait(int64_t millis=Monitor::kNoTimeout)
int NativeArgCount() const
void SetReturn(const Object &value) const
ObjectPtr NativeArgAt(int index) const
ObjectPtr NativeArg0() const
static void AddSymbols(const char *dso_name, void *buffer, size_t size)
void DisableThreadInterrupts()
void SetName(const char *name)
static ThreadId GetCurrentThreadId()
static ThreadLocalKey CreateThreadLocal(ThreadDestructor destructor=nullptr)
static OSThread * Current()
void EnableThreadInterrupts()
static intptr_t ThreadIdToIntPtr(ThreadId id)
static void SleepMicros(int64_t micros)
static int64_t GetCurrentMonotonicMicros()
static void static void PrintErr(const char *format,...) PRINTF_ATTRIBUTE(1
static char static char * VSCreate(Zone *zone, const char *format, va_list args)
static void PrepareToAbort()
static int64_t GetCurrentMonotonicFrequency()
static char * SCreate(Zone *zone, const char *format,...) PRINTF_ATTRIBUTE(2
static int64_t GetCurrentMonotonicTicks()
UntaggedObject * untag() const
intptr_t GetClassId() const
intptr_t GetClassIdMayBeSmi() const
intptr_t GetClassId() const
void SetImmutable() const
virtual const char * ToCString() const
Monitor * tasks_lock() const
Dart_PersistentHandle apiHandle()
static intptr_t ptr_offset()
void set_ptr(ObjectPtr ref)
static PersistentHandle * Cast(Dart_PersistentHandle handle)
static Dart_Port GetOriginId(Dart_Port id)
static bool PostMessage(std::unique_ptr< Message > message, bool before_events=false)
static ErrorPtr CompileAll()
static void DumpStackTrace(void *context)
static void Dedup(Thread *thread)
static SendPortPtr New(Dart_Port id, Heap::Space space=Heap::kNew)
static void SendEmbedderEvent(Isolate *isolate, const char *stream_id, const char *event_kind, const uint8_t *bytes, intptr_t bytes_len)
static void SetDartLibraryKernelForSources(const uint8_t *kernel_bytes, intptr_t kernel_length)
static void SetEmbedderStreamCallbacks(Dart_ServiceStreamListenCallback listen_callback, Dart_ServiceStreamCancelCallback cancel_callback)
static void RegisterRootEmbedderCallback(const char *name, Dart_ServiceRequestCallback callback, void *user_data)
static void RegisterIsolateEmbedderCallback(const char *name, Dart_ServiceRequestCallback callback, void *user_data)
static Dart_ServiceStreamCancelCallback stream_cancel_callback()
static Dart_ServiceStreamListenCallback stream_listen_callback()
static void SetEmbedderInformationCallback(Dart_EmbedderInformationCallback callback)
static bool EnableTimelineStreams(char *categories_list)
static SmiPtr New(intptr_t value)
static bool IsValid(int64_t value)
static const Snapshot * SetupFromBuffer(const void *raw_memory)
static const char * KindToCString(Kind kind)
static constexpr intptr_t kMaxElements
static StringPtr NewFormatted(const char *format,...) PRINTF_ATTRIBUTE(1
bool IsOneByteString() const
static StringPtr ConcatAll(const Array &strings, Heap::Space space=Heap::kNew)
static StringPtr New(const char *cstr, Heap::Space space=Heap::kNew)
intptr_t CharSize() const
void ToUTF8(uint8_t *utf8_array, intptr_t array_len) const
uint16_t CharAt(intptr_t index) const
static StringPtr SubString(const String &str, intptr_t begin_index, Heap::Space space=Heap::kNew)
static StringPtr Concat(const String &str1, const String &str2, Heap::Space space=Heap::kNew)
static const char * ToCString(Thread *thread, StringPtr ptr)
static StringPtr FromUTF16(const uint16_t *utf16_array, intptr_t array_len, Heap::Space space=Heap::kNew)
static StringPtr FromUTF32(const int32_t *utf32_array, intptr_t array_len, Heap::Space space=Heap::kNew)
static StringPtr FromUTF8(const uint8_t *utf8_array, intptr_t array_len, Heap::Space space=Heap::kNew)
static const String & True()
static const String & False()
static const String & Empty()
static const String & Dot()
static void DumpTable(IsolateGroup *isolate_group)
void UnwindScopes(uword stack_marker)
ApiLocalScope * api_top_scope() const
static Thread * Current()
bool IsValidHandle(Dart_Handle object) const
static void ExitIsolateGroupAsHelper(bool bypass_safepoint)
uword top_exit_frame_info() const
bool IsDartMutatorThread() const
ExecutionState execution_state() const
Isolate * isolate() const
IsolateGroup * isolate_group() const
static void EnterIsolate(Isolate *isolate)
static void ExitIsolate(bool isolate_shutdown=false)
ErrorPtr sticky_error() const
static bool EnterIsolateGroupAsHelper(IsolateGroup *isolate_group, TaskKind kind, bool bypass_safepoint)
void SetTypeAt(intptr_t index, const AbstractType &value) const
static TypeArgumentsPtr New(intptr_t len, Heap::Space space=Heap::kOld)
TypeArgumentsPtr GetInstanceTypeArguments(Thread *thread, bool canonicalize=true) const
static TypePtr VoidType()
TypePtr ToNullability(Nullability value, Heap::Space space) const
static TypePtr New(const Class &clazz, const TypeArguments &arguments, Nullability nullability=Nullability::kLegacy, Heap::Space space=Heap::kOld)
static TypePtr NeverType()
static TypePtr DynamicType()
virtual ClassPtr type_class() const
static TypePtr NewNonParameterizedType(const Class &type_class)
intptr_t ElementSizeInBytes() const
void * DataAddr(intptr_t byte_offset) const
static TypedDataViewPtr New(intptr_t class_id, Heap::Space space=Heap::kNew)
static bool IsTypedData(const Instance &obj)
static intptr_t MaxElements(intptr_t class_id)
static TypedDataPtr New(intptr_t class_id, intptr_t len, Heap::Space space=Heap::kNew)
static UnhandledExceptionPtr New(const Instance &exception, const Instance &stacktrace, Heap::Space space=Heap::kNew)
static uword ToAddr(const UntaggedObject *raw_obj)
bool InVMIsolateHeap() const
static UserTagPtr New(const String &label, Heap::Space space=Heap::kOld)
UserTagPtr MakeActive() const
static intptr_t Length(int32_t ch)
static bool IsValid(const uint8_t *utf8_array, intptr_t array_len)
static char * StrDup(const char *s)
static bool RangeCheck(intptr_t offset, intptr_t count, intptr_t length)
static char * SCreate(const char *format,...) PRINTF_ATTRIBUTE(1
static const char * String()
void * AllocUnsafe(intptr_t size)
ElementType * Alloc(intptr_t length)
static Object & LoadEntireProgram(Program *program, bool process_pending_classes=true)
#define DART_INITIALIZE_PARAMS_CURRENT_VERSION
Dart_Handle(* Dart_EnvironmentCallback)(Dart_Handle name)
void(* Dart_StreamingWriteCallback)(void *callback_data, const uint8_t *buffer, intptr_t size)
@ Dart_KernelCompilationStatus_Unknown
@ Dart_KernelCompilationStatus_Ok
void(* Dart_IsolateCleanupCallback)(void *isolate_group_data, void *isolate_data)
void(* Dart_MessageNotifyCallback)(Dart_Isolate destination_isolate)
struct _Dart_Handle * Dart_Handle
struct _Dart_Isolate * Dart_Isolate
Dart_NativeFunction(* Dart_NativeEntryResolver)(Dart_Handle name, int num_of_arguments, bool *auto_setup_scope)
void(* Dart_StreamingCloseCallback)(void *callback_data)
void(* Dart_HandleFinalizer)(void *isolate_callback_data, void *peer)
struct _Dart_IsolateGroup * Dart_IsolateGroup
const uint8_t *(* Dart_NativeEntrySymbol)(Dart_NativeFunction nf)
void *(* Dart_FfiNativeResolver)(const char *name, uintptr_t args_n)
struct _Dart_NativeArguments * Dart_NativeArguments
@ Dart_TypedData_kFloat32x4
@ Dart_TypedData_kInt32x4
@ Dart_TypedData_kFloat64x2
@ Dart_TypedData_kFloat32
@ Dart_TypedData_kFloat64
@ Dart_TypedData_kUint8Clamped
@ Dart_TypedData_kByteData
@ Dart_TypedData_kInvalid
Dart_Handle Dart_PersistentHandle
struct _Dart_FinalizableHandle * Dart_FinalizableHandle
void(* Dart_CreateLoadingUnitCallback)(void *callback_data, intptr_t loading_unit_id, void **write_callback_data, void **write_debug_callback_data)
void(* Dart_IsolateShutdownCallback)(void *isolate_group_data, void *isolate_data)
void *(* Dart_HeapSamplingCreateCallback)(Dart_Isolate isolate, Dart_IsolateGroup isolate_group, const char *cls_name, intptr_t allocation_size)
Dart_Handle(* Dart_LibraryTagHandler)(Dart_LibraryTag tag, Dart_Handle library_or_package_map_url, Dart_Handle url)
@ Dart_NativeArgument_kString
@ Dart_NativeArgument_kInt64
@ Dart_NativeArgument_kNativeFields
@ Dart_NativeArgument_kInstance
@ Dart_NativeArgument_kInt32
@ Dart_NativeArgument_kUint64
@ Dart_NativeArgument_kUint32
@ Dart_NativeArgument_kDouble
@ Dart_NativeArgument_kBool
int64_t Dart_IsolateGroupId
char *(* Dart_DwarfStackTraceFootnoteCallback)(void *addresses[], intptr_t count)
struct _Dart_WeakPersistentHandle * Dart_WeakPersistentHandle
Dart_KernelCompilationVerbosityLevel
Dart_Handle(* Dart_DeferredLoadHandler)(intptr_t loading_unit_id)
void(* Dart_HeapSamplingDeleteCallback)(void *data)
void(* Dart_HeapSamplingReportCallback)(void *context, void *data)
#define ISOLATE_GROUP_METRIC_API(type, variable, name, unit)
#define CHECK_ERROR_HANDLE(error)
#define GET_LIST_ELEMENT(thread, type, obj, index)
#define GET_LIST_RANGE(thread, type, obj, offset, length)
#define SET_LIST_ELEMENT_AS_BYTES(type, obj, native_array, offset, length)
#define GET_LIST_ELEMENT_AS_BYTES(type, obj, native_array, offset, length)
#define GET_LIST_LENGTH(zone, type, obj, len)
#define DEFINE_UNWRAP(type)
#define SET_LIST_ELEMENT(type, obj, index, value)
#define ISOLATE_METRIC_API(type, variable, name, unit)
#define API_TIMELINE_DURATION(thread)
#define CHECK_ISOLATE(isolate)
#define DARTSCOPE(thread)
#define CHECK_ISOLATE_GROUP(isolate_group)
#define RETURN_TYPE_ERROR(zone, dart_handle, type)
#define ASSERT_CALLBACK_STATE(thread)
#define CHECK_LENGTH(length, max_elements)
#define RETURN_NULL_ERROR(parameter)
#define CHECK_NO_ISOLATE(isolate)
#define START_NO_CALLBACK_SCOPE(thread)
#define API_TIMELINE_BEGIN_END(thread)
#define CHECK_API_SCOPE(thread)
#define CHECK_NULL(parameter)
#define END_NO_CALLBACK_SCOPE(thread)
#define CHECK_CALLBACK_STATE(thread)
const EmbeddedViewParams * params
FlutterSemanticsFlag flags
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
static const uint8_t buffer[]
const uint8_t uint32_t uint32_t GError ** error
uint32_t uint32_t * format
#define DECLARE_FLAG(type, name)
#define DEFINE_FLAG(type, name, default_value, comment)
Dart_NativeFunction function
#define HANDLESCOPE(thread)
#define DART_API_ISOLATE_GROUP_METRIC_LIST(V)
#define ISOLATE_METRIC_LIST(V)
DART_EXPORT bool Dart_HasServiceMessages()
DART_EXPORT Dart_Handle Dart_StringToUTF8(Dart_Handle str, uint8_t **utf8_array, intptr_t *length)
static bool GetNativeStringArgument(NativeArguments *arguments, int arg_index, Dart_Handle *str, void **peer)
DART_EXPORT bool Dart_IsLibrary(Dart_Handle object)
static bool Equals(const Object &expected, const Object &actual)
DART_EXPORT Dart_Handle Dart_SetFfiNativeResolver(Dart_Handle library, Dart_FfiNativeResolver resolver)
bool IsTypedDataViewClassId(intptr_t index)
static FunctionPtr FindCoreLibPrivateFunction(Zone *zone, const String &name)
DART_EXPORT void Dart_PrepareToAbort()
bool IsTypedDataClassId(intptr_t index)
DART_EXPORT void Dart_ReportSurvivingAllocations(Dart_HeapSamplingReportCallback callback, void *context, bool force_gc)
DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index)
DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_Handle Dart_ClassLibrary(Dart_Handle cls_type)
static TypeArgumentsPtr TypeArgumentsForElementType(ObjectStore *store, Dart_CoreType_Id element_type_id)
static ObjectPtr ResolveConstructor(const char *current_func, const Class &cls, const String &class_name, const String &dotted_name, int num_args)
DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void *peer)
DART_EXPORT bool Dart_DetectNullSafety(const char *script_uri, const char *package_config, const char *original_working_directory, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
DART_EXPORT bool Dart_IsDouble(Dart_Handle object)
DART_EXPORT bool Dart_IsInstance(Dart_Handle object)
bool IsOneByteStringClassId(intptr_t index)
DART_EXPORT void Dart_DisableHeapSampling()
DART_EXPORT Dart_Handle Dart_IsNonNullableType(Dart_Handle type, bool *result)
static bool GetNativeIntegerArgument(NativeArguments *arguments, int arg_index, int64_t *value)
DART_EXPORT Dart_Handle Dart_SetCurrentUserTag(Dart_Handle user_tag)
DART_EXPORT bool Dart_IsCompilationError(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_CreateAppAOTSnapshotAsElfs(Dart_CreateLoadingUnitCallback next_callback, void *next_callback_data, bool strip, Dart_StreamingWriteCallback write_callback, Dart_StreamingCloseCallback close_callback)
DART_EXPORT Dart_Handle Dart_Allocate(Dart_Handle type)
DART_EXPORT Dart_Handle Dart_GetNativeStringArgument(Dart_NativeArguments args, int arg_index, void **peer)
DART_EXPORT bool Dart_IsBoolean(Dart_Handle object)
DART_EXPORT void Dart_EnterScope()
DART_EXPORT Dart_Handle Dart_GetObfuscationMap(uint8_t **buffer, intptr_t *buffer_length)
DART_EXPORT bool Dart_IsStringLatin1(Dart_Handle object)
DART_EXPORT void Dart_SetPersistentHandle(Dart_PersistentHandle obj1, Dart_Handle obj2)
DART_EXPORT Dart_Port Dart_GetMainPortId()
DART_EXPORT Dart_Handle Dart_FinalizeLoading(bool complete_futures)
DART_EXPORT Dart_Handle Dart_NewUserTag(const char *label)
static Dart_Handle GetNativeFieldsOfArgument(NativeArguments *arguments, int arg_index, int num_fields, intptr_t *field_values, const char *current_func)
DART_EXPORT Dart_Handle Dart_GetStickyError()
static InstancePtr GetMapInstance(Zone *zone, const Object &obj)
DART_EXPORT char * Dart_GetUserTagLabel(Dart_Handle user_tag)
DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception, Dart_Handle stacktrace)
const int kTypedDataCidRemainderUnmodifiable
static bool GetNativeDoubleArgument(NativeArguments *arguments, int arg_index, double *value)
DART_EXPORT void Dart_StartProfiling()
static bool GetNativeUnsignedIntegerArgument(NativeArguments *arguments, int arg_index, uint64_t *value)
DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_TypeNever()
DART_EXPORT Dart_Handle Dart_DebugName()
DART_EXPORT Dart_Handle Dart_False()
DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle)
DART_EXPORT Dart_IsolateGroupId Dart_CurrentIsolateGroupId()
DART_EXPORT char * Dart_SetServiceStreamCallbacks(Dart_ServiceStreamListenCallback listen_callback, Dart_ServiceStreamCancelCallback cancel_callback)
DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj, int index, intptr_t *value)
DART_EXPORT Dart_Handle Dart_NewStringFromUTF32(const int32_t *utf32_array, intptr_t length)
DART_EXPORT Dart_Handle Dart_Invoke(Dart_Handle target, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle Dart_NewDouble(double value)
DART_EXPORT const char * Dart_IsolateServiceId(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_CreateAppAOTSnapshotAsAssemblies(Dart_CreateLoadingUnitCallback next_callback, void *next_callback_data, bool strip, Dart_StreamingWriteCallback write_callback, Dart_StreamingCloseCallback close_callback)
DART_EXPORT void Dart_ThreadEnableProfiling()
DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle cls_type)
DART_EXPORT Dart_Handle Dart_GetPeer(Dart_Handle object, void **peer)
static Dart_Handle NewExternalByteData(Thread *thread, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
DART_EXPORT void * Dart_GetNativeIsolateGroupData(Dart_NativeArguments args)
DART_EXPORT bool Dart_IsKernel(const uint8_t *buffer, intptr_t buffer_size)
bool ResolveUri(const char *ref_uri, const char *base_uri, const char **target_uri)
DART_EXPORT bool Dart_HasStickyError()
DART_EXPORT Dart_Handle Dart_StringToLatin1(Dart_Handle str, uint8_t *latin1_array, intptr_t *length)
DART_EXPORT void Dart_NotifyLowMemory()
DART_EXPORT void Dart_SetThreadName(const char *name)
DART_EXPORT Dart_Handle Dart_True()
DART_EXPORT Dart_Handle Dart_RootLibrary()
DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, Dart_Handle class_name)
DART_EXPORT bool Dart_IsNumber(Dart_Handle object)
static intptr_t kInitialSize
static Dart_Handle NewTypedData(Thread *thread, intptr_t cid, intptr_t length)
DART_EXPORT void Dart_SetBooleanReturnValue(Dart_NativeArguments args, bool retval)
DART_EXPORT void Dart_SetEmbedderInformationCallback(Dart_EmbedderInformationCallback callback)
const char * CanonicalFunction(const char *func)
bool IsNumberClassId(intptr_t index)
DART_EXPORT Dart_Handle Dart_NewStringFromUTF16(const uint16_t *utf16_array, intptr_t length)
bool IsTypeClassId(intptr_t index)
DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer, bool *fits)
DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj, int *count)
DART_EXPORT Dart_MessageNotifyCallback Dart_GetMessageNotifyCallback()
void * malloc(size_t size)
static bool IsFfiCompound(Thread *T, const Object &obj)
static bool IsCompiletimeErrorObject(Zone *zone, const Object &obj)
DART_EXPORT Dart_Handle Dart_GetDefaultUserTag()
DART_EXPORT Dart_Handle Dart_TypeDynamic()
DART_EXPORT void Dart_SetShouldPauseOnExit(bool should_pause)
const char *const class_name
DART_EXPORT Dart_Handle Dart_Precompile()
DART_EXPORT void Dart_IsolateFlagsInitialize(Dart_IsolateFlags *flags)
DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception)
constexpr intptr_t kIntptrMin
DART_EXPORT Dart_Handle Dart_StringStorageSize(Dart_Handle str, intptr_t *size)
DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value)
DART_EXPORT bool Dart_IsUnhandledExceptionError(Dart_Handle object)
static Dart_Handle NewExternalTypedDataWithFinalizer(Dart_TypedData_Type type, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj, bool *value)
DART_EXPORT Dart_Handle Dart_NewExternalTypedDataWithFinalizer(Dart_TypedData_Type type, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static Dart_Handle HandleFromFinalizable(Dart_FinalizableHandle object)
DART_EXPORT Dart_Handle Dart_NewStringFromUTF8(const uint8_t *utf8_array, intptr_t length)
DART_EXPORT void Dart_PropagateError(Dart_Handle handle)
static Dart_Handle InitNewReadOnlyApiHandle(ObjectPtr raw)
bool IsUnmodifiableTypedDataViewClassId(intptr_t index)
DART_EXPORT Dart_Handle Dart_GetNativeSymbol(Dart_Handle library, Dart_NativeEntrySymbol *resolver)
static InstancePtr GetListInstance(Zone *zone, const Object &obj)
@ kUnmodifiableByteDataViewCid
DART_EXPORT Dart_Handle Dart_SetDeferredLoadHandler(Dart_DeferredLoadHandler handler)
DART_EXPORT void Dart_SetWeakHandleReturnValue(Dart_NativeArguments args, Dart_WeakPersistentHandle rval)
static void DropRegExpMatchCode(Zone *zone)
DART_EXPORT void Dart_StopProfiling()
DART_EXPORT void * Dart_IsolateGroupData(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_GetNonNullableType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT Dart_FinalizableHandle Dart_NewFinalizableHandle(Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT const char * Dart_GetError(Dart_Handle handle)
DART_EXPORT bool Dart_IsPausedOnStart()
DART_EXPORT Dart_Handle Dart_NewTypedData(Dart_TypedData_Type type, intptr_t length)
DART_EXPORT bool Dart_WriteProfileToTimeline(Dart_Port main_port, char **error)
DART_EXPORT Dart_Handle Dart_HandleFromWeakPersistent(Dart_WeakPersistentHandle object)
DART_EXPORT Dart_IsolateGroup Dart_CurrentIsolateGroup()
DART_EXPORT uint8_t * Dart_ScopeAllocate(intptr_t size)
DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args, Dart_Handle retval)
DART_EXPORT Dart_Handle Dart_GetStaticMethodClosure(Dart_Handle library, Dart_Handle cls_type, Dart_Handle function_name)
DART_EXPORT void Dart_RecordTimelineEvent(const char *label, int64_t timestamp0, int64_t timestamp1_or_id, intptr_t flow_id_count, const int64_t *flow_ids, Dart_Timeline_Event_Type type, intptr_t argument_count, const char **argument_names, const char **argument_values)
DART_EXPORT char * Dart_SetFileModifiedCallback(Dart_FileModifiedCallback file_modified_callback)
DART_EXPORT Dart_Handle Dart_CreateAppJITSnapshotAsBlobs(uint8_t **isolate_snapshot_data_buffer, intptr_t *isolate_snapshot_data_size, uint8_t **isolate_snapshot_instructions_buffer, intptr_t *isolate_snapshot_instructions_size)
DART_EXPORT void Dart_NotifyDestroyed()
DART_EXPORT Dart_Handle Dart_CreateAppAOTSnapshotAsElf(Dart_StreamingWriteCallback callback, void *callback_data, bool strip, void *debug_callback_data)
DART_EXPORT char * Dart_Initialize(Dart_InitializeParams *params)
DART_EXPORT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name)
DART_EXPORT Dart_Handle Dart_GetNativeResolver(Dart_Handle library, Dart_NativeEntryResolver *resolver)
DART_EXPORT Dart_Handle Dart_IsNullableType(Dart_Handle type, bool *result)
DART_EXPORT Dart_Handle Dart_GetCurrentUserTag()
DART_EXPORT Dart_Handle Dart_MapGetAt(Dart_Handle map, Dart_Handle key)
DART_EXPORT Dart_Handle Dart_DeferredLoadCompleteError(intptr_t loading_unit_id, const char *error_message, bool transient)
DART_EXPORT Dart_Handle Dart_FunctionIsStatic(Dart_Handle function, bool *is_static)
DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char *str)
static Dart_Handle NewExternalTypedData(Thread *thread, intptr_t cid, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, bool unmodifiable)
DART_EXPORT void Dart_SetHeapSamplingPeriod(intptr_t bytes)
DART_EXPORT int64_t Dart_TimelineGetTicks()
DART_EXPORT bool Dart_IsFuture(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object)
static Dart_WeakPersistentHandle AllocateWeakPersistentHandle(Thread *thread, const Object &ref, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_Handle Dart_ClosureFunction(Dart_Handle closure)
DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object, Dart_TypedData_Type *type, void **data, intptr_t *len)
DART_EXPORT Dart_Handle Dart_GetNullableType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT Dart_Isolate Dart_CurrentIsolate()
DART_EXPORT Dart_Handle Dart_NewListOfTypeFilled(Dart_Handle element_type, Dart_Handle fill_object, intptr_t length)
DART_EXPORT void Dart_RegisterRootServiceRequestCallback(const char *name, Dart_ServiceRequestCallback callback, void *user_data)
DART_EXPORT void Dart_DumpNativeStackTrace(void *context)
DART_EXPORT const char * Dart_VersionString()
DART_EXPORT Dart_Handle Dart_InvokeConstructor(Dart_Handle object, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list, intptr_t index, Dart_Handle value)
DART_EXPORT char * Dart_WriteHeapSnapshot(Dart_HeapSnapshotWriteChunkCallback write, void *context)
DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer, const char **value)
DART_EXPORT bool Dart_SetEnabledTimelineCategory(const char *categories)
DART_EXPORT Dart_Handle Dart_FunctionName(Dart_Handle function)
DART_EXPORT Dart_Handle Dart_StringToUTF16(Dart_Handle str, uint16_t *utf16_array, intptr_t *length)
DART_EXPORT bool Dart_IsKernelIsolate(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_NewBoolean(bool value)
DART_EXPORT char * Dart_Cleanup()
static Dart_Handle NewByteData(Thread *thread, intptr_t length)
static Dart_Handle DeferredLoadComplete(intptr_t loading_unit_id, bool error, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const char *error_message, bool transient_error)
static Dart_Handle GetTypeCommon(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments, Nullability nullability)
DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object)
DART_EXPORT bool Dart_IsError(Dart_Handle handle)
DART_EXPORT char * Dart_ServiceSendDataEvent(const char *stream_id, const char *event_kind, const uint8_t *bytes, intptr_t bytes_length)
DART_EXPORT Dart_Handle Dart_CreateAppAOTSnapshotAsAssembly(Dart_StreamingWriteCallback callback, void *callback_data, bool strip, void *debug_callback_data)
DART_EXPORT Dart_Handle Dart_LibraryResolvedUrl(Dart_Handle library)
DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj, int index, intptr_t value)
DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args, int64_t retval)
DART_EXPORT void Dart_DeleteWeakPersistentHandle(Dart_WeakPersistentHandle object)
DART_EXPORT Dart_KernelCompilationResult Dart_CompileToKernel(const char *script_uri, const uint8_t *platform_kernel, intptr_t platform_kernel_size, bool incremental_compile, bool for_snapshot, bool embed_sources, const char *package_config, Dart_KernelCompilationVerbosityLevel verbosity)
const int kTypedDataCidRemainderExternal
DART_EXPORT Dart_Handle Dart_EmptyString()
DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id)
DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object, Dart_Handle type, bool *value)
DART_EXPORT Dart_Handle Dart_CopyUTF8EncodingOfString(Dart_Handle str, uint8_t *utf8_array, intptr_t length)
DART_EXPORT Dart_Handle Dart_ErrorGetStackTrace(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_TypeToNullableType(Dart_Handle type)
DART_EXPORT Dart_Handle Dart_GetNativeFieldsOfArgument(Dart_NativeArguments args, int arg_index, int num_fields, intptr_t *field_values)
DART_EXPORT Dart_PerformanceMode Dart_SetPerformanceMode(Dart_PerformanceMode mode)
static ObjectPtr CallStatic3Args(Zone *zone, const String &name, const Instance &arg0, const Instance &arg1, const Instance &arg2)
DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list, intptr_t offset, const uint8_t *native_array, intptr_t length)
DART_EXPORT Dart_Isolate Dart_CreateIsolateInGroup(Dart_Isolate group_member, const char *name, Dart_IsolateShutdownCallback shutdown_callback, Dart_IsolateCleanupCallback cleanup_callback, void *child_isolate_data, char **error)
DART_EXPORT bool Dart_RunLoopAsync(bool errors_are_fatal, Dart_Port on_error_port, Dart_Port on_exit_port, char **error)
DART_EXPORT Dart_Handle Dart_NewExternalTypedData(Dart_TypedData_Type type, void *data, intptr_t length)
DART_EXPORT Dart_Handle Dart_TypeToNonNullableType(Dart_Handle type)
DART_EXPORT Dart_Handle Dart_AllocateWithNativeFields(Dart_Handle type, intptr_t num_native_fields, const intptr_t *native_fields)
static bool CanTypeContainNull(const Type &type)
DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer, uint64_t *value)
DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object)
DART_EXPORT bool Dart_IsPausedOnExit()
DART_EXPORT bool Dart_InvokeVMServiceMethod(uint8_t *request_json, intptr_t request_json_length, uint8_t **response_json, intptr_t *response_json_length, char **error)
DART_EXPORT Dart_Handle Dart_FunctionOwner(Dart_Handle function)
DART_EXPORT Dart_Handle Dart_StringGetProperties(Dart_Handle object, intptr_t *char_size, intptr_t *str_len, void **peer)
DART_EXPORT Dart_Handle Dart_NewIntegerFromUint64(uint64_t value)
DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate)
DART_EXPORT bool Dart_IsMap(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_SetNativeResolver(Dart_Handle library, Dart_NativeEntryResolver resolver, Dart_NativeEntrySymbol symbol)
static Dart_Handle IsOfTypeNullabilityHelper(Dart_Handle type, Nullability nullability, bool *result)
DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj, double *value)
DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args, int index)
DART_EXPORT void Dart_ExitIsolate()
DART_EXPORT void Dart_SetPausedOnStart(bool paused)
DART_EXPORT bool Dart_IsFunction(Dart_Handle handle)
DART_EXPORT void * Dart_IsolateData(Dart_Isolate isolate)
DART_EXPORT void Dart_SetTimelineRecorderCallback(Dart_TimelineRecorderCallback callback)
DART_EXPORT char * Dart_IsolateMakeRunnable(Dart_Isolate isolate)
static const char * GetErrorString(Thread *thread, const Object &obj)
DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance)
DART_EXPORT Dart_Isolate Dart_CreateIsolateGroup(const char *script_uri, const char *name, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, Dart_IsolateFlags *flags, void *isolate_group_data, void *isolate_data, char **error)
DART_EXPORT Dart_Handle Dart_LibraryHandleError(Dart_Handle library_in, Dart_Handle error_in)
DART_EXPORT Dart_Handle Dart_NewByteBuffer(Dart_Handle typed_data)
DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container, Dart_Handle name, Dart_Handle value)
DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t *len)
raw_obj untag() -> num_entries()) VARIABLE_COMPRESSED_VISITOR(Array, Smi::Value(raw_obj->untag() ->length())) VARIABLE_COMPRESSED_VISITOR(TypedData, TypedData::ElementSizeInBytes(raw_obj->GetClassId()) *Smi::Value(raw_obj->untag() ->length())) VARIABLE_COMPRESSED_VISITOR(Record, RecordShape(raw_obj->untag() ->shape()).num_fields()) VARIABLE_NULL_VISITOR(CompressedStackMaps, CompressedStackMaps::PayloadSizeOf(raw_obj)) VARIABLE_NULL_VISITOR(OneByteString, Smi::Value(raw_obj->untag() ->length())) VARIABLE_NULL_VISITOR(TwoByteString, Smi::Value(raw_obj->untag() ->length())) intptr_t UntaggedField::VisitFieldPointers(FieldPtr raw_obj, ObjectPointerVisitor *visitor)
DART_EXPORT bool Dart_IsTearOff(Dart_Handle object)
static Dart_Handle TypeToHelper(Dart_Handle type, Nullability nullability)
DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list, intptr_t offset, uint8_t *native_array, intptr_t length)
DART_EXPORT Dart_Handle Dart_RunLoop()
DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle kernel_buffer)
DART_EXPORT void * Dart_CurrentIsolateGroupData()
DART_EXPORT Dart_Handle Dart_NewListOfType(Dart_Handle element_type, intptr_t length)
static bool InstanceIsType(const Thread *thread, const Instance &instance, const Type &type)
DART_EXPORT bool Dart_IsType(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map)
DART_EXPORT void Dart_ThreadDisableProfiling()
static void KillNonMainIsolatesSlow(Thread *thread, Isolate *main_isolate)
DART_EXPORT bool Dart_IsPrecompiledRuntime()
DART_EXPORT Dart_Isolate Dart_CreateIsolateGroupFromKernel(const char *script_uri, const char *name, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size, Dart_IsolateFlags *flags, void *isolate_group_data, void *isolate_data, char **error)
DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT char * Dart_SetVMFlags(int argc, const char **argv)
DART_EXPORT void Dart_NotifyIdle(int64_t deadline)
DART_EXPORT Dart_Handle Dart_NewListOf(Dart_CoreType_Id element_type_id, intptr_t length)
DART_EXPORT Dart_KernelCompilationResult Dart_KernelListDependencies()
DART_EXPORT Dart_Handle Dart_CreateVMAOTSnapshotAsAssembly(Dart_StreamingWriteCallback callback, void *callback_data)
DART_EXPORT Dart_Handle Dart_DeferredLoadComplete(intptr_t loading_unit_id, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions)
DART_EXPORT void Dart_DeleteFinalizableHandle(Dart_FinalizableHandle object, Dart_Handle strong_ref_to_object)
void DumpTypeTable(Isolate *isolate)
DART_EXPORT Dart_Handle Dart_SetLibraryTagHandler(Dart_LibraryTagHandler handler)
DART_EXPORT Dart_Handle Dart_SortClasses()
DART_EXPORT Dart_Handle Dart_TypeVoid()
DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key)
DART_EXPORT void Dart_SetPausedOnExit(bool paused)
DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_LoadingUnitLibraryUris(intptr_t loading_unit_id)
DART_EXPORT void Dart_ExitScope()
DART_EXPORT int64_t Dart_TimelineGetTicksFrequency()
DART_EXPORT void Dart_RegisterHeapSamplingCallback(Dart_HeapSamplingCreateCallback create_callback, Dart_HeapSamplingDeleteCallback delete_callback)
static void RunLoopDone(uword param)
DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfExternalTypedData(Dart_Handle object)
DART_EXPORT const char * Dart_DebugNameToCString()
std::unique_ptr< Message > WriteMessage(bool same_group, const Object &obj, Dart_Port dest_port, Message::Priority priority)
DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer, bool *fits)
DART_EXPORT Dart_Handle Dart_NewApiError(const char *error)
DART_EXPORT Dart_Handle Dart_ListGetRange(Dart_Handle list, intptr_t offset, intptr_t length, Dart_Handle *result)
DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t *len)
static InstancePtr AllocateObject(Thread *thread, const Class &cls)
DART_EXPORT void Dart_SetMessageNotifyCallback(Dart_MessageNotifyCallback message_notify_callback)
DART_EXPORT Dart_Handle Dart_NewList(intptr_t length)
static ObjectPtr CallStatic1Arg(Zone *zone, const String &name, const Instance &arg0)
const StackTrace & GetCurrentStackTrace(int skip_frames)
DART_EXPORT void Dart_KillIsolate(Dart_Isolate handle)
static bool IsSnapshotCompatible(Snapshot::Kind vm_kind, Snapshot::Kind isolate_kind)
DART_EXPORT Dart_Handle Dart_NewCompilationError(const char *error)
DART_EXPORT bool Dart_ShouldPauseOnStart()
DART_EXPORT void Dart_SetDartLibrarySourcesKernel(const uint8_t *platform_kernel, const intptr_t platform_kernel_size)
DART_EXPORT Dart_Handle Dart_GetNativeDoubleArgument(Dart_NativeArguments args, int index, double *value)
DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url)
DART_EXPORT bool Dart_IsList(Dart_Handle object)
DART_EXPORT bool Dart_IsApiError(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_DefaultCanonicalizeUrl(Dart_Handle base_url, Dart_Handle url)
DART_EXPORT Dart_Handle Dart_GetLoadedLibraries()
DART_EXPORT void * Dart_CurrentIsolateData()
DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception)
DART_EXPORT Dart_Handle Dart_GetNativeIntegerArgument(Dart_NativeArguments args, int index, int64_t *value)
DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args)
DART_EXPORT Dart_Port Dart_KernelPort()
DART_EXPORT void Dart_AddSymbols(const char *dso_name, void *buffer, intptr_t buffer_size)
DART_EXPORT Dart_Handle Dart_LoadScriptFromKernel(const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT bool Dart_IsInteger(Dart_Handle object)
DART_EXPORT int64_t Dart_TimelineGetMicros()
pthread_key_t ThreadLocalKey
DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2, bool *value)
DART_EXPORT bool Dart_IsNull(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library)
DART_EXPORT Dart_Handle Dart_SetEnvironmentCallback(Dart_EnvironmentCallback callback)
static Dart_Handle LoadLibrary(Thread *T, const ExternalTypedData &td)
bool IsIntegerClassId(intptr_t index)
DART_EXPORT bool Dart_IsVariable(Dart_Handle handle)
DART_EXPORT void Dart_SetDwarfStackTraceFootnoteCallback(Dart_DwarfStackTraceFootnoteCallback callback)
DART_EXPORT void Dart_SetDoubleReturnValue(Dart_NativeArguments args, double retval)
DART_EXPORT bool Dart_IsTypedData(Dart_Handle handle)
DART_EXPORT bool Dart_IsVMFlagSet(const char *flag_name)
DART_EXPORT Dart_Handle Dart_Null()
static Dart_TypedData_Type GetType(intptr_t class_id)
static ObjectPtr GetByteBufferConstructor(Thread *thread, const String &class_name, const String &constructor_name, intptr_t num_args)
DART_EXPORT bool Dart_IsReloading()
DART_EXPORT void Dart_SetStickyError(Dart_Handle error)
DART_EXPORT bool Dart_IsString(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_New(Dart_Handle type, Dart_Handle constructor_name, int number_of_arguments, Dart_Handle *arguments)
void DumpTypeParameterTable(Isolate *isolate)
Isolate * CreateWithinExistingIsolateGroup(IsolateGroup *group, const char *name, char **error)
const char *const function_name
static int8_t data[kExtLength]
DART_EXPORT bool Dart_ShouldPauseOnExit()
DART_EXPORT Dart_Handle Dart_SetRootLibrary(Dart_Handle library)
DART_EXPORT Dart_Handle Dart_GetNativeBooleanArgument(Dart_NativeArguments args, int index, bool *value)
DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object, const char **cstr)
DART_EXPORT bool Dart_KernelIsolateIsRunning()
DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t **vm_snapshot_data_buffer, intptr_t *vm_snapshot_data_size, uint8_t **isolate_snapshot_data_buffer, intptr_t *isolate_snapshot_data_size, bool is_core)
DART_EXPORT Dart_Handle Dart_SendPortGetId(Dart_Handle port, Dart_Port *port_id)
static Dart_Isolate CreateIsolate(IsolateGroup *group, bool is_new_group, const char *name, void *isolate_data, char **error)
DART_EXPORT Dart_Handle Dart_HandleFromPersistent(Dart_PersistentHandle object)
DART_EXPORT Dart_Handle Dart_GetType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT void Dart_ShutdownIsolate()
DART_EXPORT bool Dart_IsClosure(Dart_Handle object)
DART_EXPORT bool Dart_HasLivePorts()
DART_EXPORT void Dart_RegisterIsolateServiceRequestCallback(const char *name, Dart_ServiceRequestCallback callback, void *user_data)
DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args, intptr_t *value)
DART_EXPORT bool Dart_HandleServiceMessages()
void DumpTypeArgumentsTable(Isolate *isolate)
DART_EXPORT Dart_Handle Dart_NewUnmodifiableExternalTypedDataWithFinalizer(Dart_TypedData_Type type, const void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle object)
static Dart_Handle SetupArguments(Thread *thread, int num_args, Dart_Handle *arguments, int extra_args, Array *args)
static Dart_FinalizableHandle AllocateFinalizableHandle(Thread *thread, const Object &ref, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static ObjectPtr CallStatic2Args(Zone *zone, const String &name, const Instance &arg0, const Instance &arg1)
DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle)
static ObjectPtr ThrowArgumentError(const char *exception_message)
DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char *str)
DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_GetNativeArguments(Dart_NativeArguments args, int num_arguments, const Dart_NativeArgument_Descriptor *argument_descriptors, Dart_NativeArgument_Value *arg_values)
static const ThreadLocalKey kUnsetThreadLocalKey
bool IsBuiltinListClassId(intptr_t index)
DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle handle)
bool IsExternalTypedDataClassId(intptr_t index)
DART_EXPORT Dart_Handle Dart_LoadLibraryFromKernel(const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2)
DART_EXPORT bool Dart_IsFatalError(Dart_Handle object)
constexpr intptr_t kIntptrMax
bool IsStringClassId(intptr_t index)
DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer, int64_t *value)
DART_EXPORT Dart_Handle Dart_StringUTF8Length(Dart_Handle str, intptr_t *len)
DART_EXPORT Dart_Handle Dart_IsLegacyType(Dart_Handle type, bool *result)
DART_EXPORT void Dart_EnableHeapSampling()
DART_EXPORT Dart_Handle Dart_HandleMessage()
DART_EXPORT void Dart_SetShouldPauseOnStart(bool should_pause)
static SkString fmt(SkColor4f c)
#define REUSABLE_OBJECT_HANDLESCOPE(thread)
void write(SkWStream *wStream, const T &text)
Dart_KernelCompilationStatus status
#define TIMELINE_DURATION(thread, stream, name)
struct _Dart_NativeArgument_Value::@83 as_string
struct _Dart_NativeArgument_Value::@84 as_native_fields
#define NOT_IN_PRODUCT(code)