runtime/lib/ffi.cc - sdk.git - Git at Google

 // Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 #include "include/dart_api.h"
 #include "include/dart_api_dl.h"
 #include "include/dart_native_api.h"
 #include "include/dart_version.h"
 #include "include/internal/dart_api_dl_impl.h"
 #include "platform/globals.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/class_id.h"
 #include "vm/compiler/ffi/native_type.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/symbols.h"

 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/compiler/assembler/assembler.h"
 #include "vm/compiler/ffi/call.h"
 #include "vm/compiler/ffi/callback.h"
 #include "vm/compiler/jit/compiler.h"
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)

 namespace dart {

 // The following functions are runtime checks on type arguments.
 // Some checks are also performed in kernel transformation, these are asserts.
 // Some checks are only performed at runtime to allow for generic code, these
 // throw ArgumentExceptions.

 static void CheckSized(const AbstractType& type_arg) {
   const classid_t type_cid = type_arg.type_class_id();
   if (IsFfiNativeTypeTypeClassId(type_cid) || IsFfiTypeVoidClassId(type_cid) ||
       IsFfiTypeNativeFunctionClassId(type_cid)) {
     const String& error = String::Handle(String::NewFormatted(
         "%s does not have a predefined size (@unsized). "
         "Unsized NativeTypes do not support [sizeOf] because their size "
         "is unknown. "
         "Consequently, [allocate], [Pointer.load], [Pointer.store], and "
         "[Pointer.elementAt] are not available.",
         String::Handle(type_arg.UserVisibleName()).ToCString()));
     Exceptions::ThrowArgumentError(error);
   }
 }

 // Calculate the size of a native type.
 //
 // You must check [IsConcreteNativeType] and [CheckSized] first to verify that
 // this type has a defined size.
 static size_t SizeOf(Zone* zone, const AbstractType& type) {
   if (IsFfiTypeClassId(type.type_class_id())) {
     return compiler::ffi::NativeType::FromAbstractType(zone, type)
         .SizeInBytes();
   } else {
     Class& struct_class = Class::Handle(type.type_class());
     Object& result = Object::Handle(
         struct_class.InvokeGetter(Symbols::SizeOfStructField(),
                                   /*throw_nsm_if_absent=*/false,
                                   /*respect_reflectable=*/false));
     ASSERT(!result.IsNull() && result.IsInteger());
     return Integer::Cast(result).AsInt64Value();
   }
 }

 // The remainder of this file implements the dart:ffi native methods.

 DEFINE_NATIVE_ENTRY(Ffi_fromAddress, 1, 1) {
   UNREACHABLE();
 }

 DEFINE_NATIVE_ENTRY(Ffi_address, 0, 1) {
   UNREACHABLE();
 }

 #define DEFINE_NATIVE_ENTRY_LOAD(type)                                         \
   DEFINE_NATIVE_ENTRY(Ffi_load##type, 0, 2) { UNREACHABLE(); }
 CLASS_LIST_FFI_NUMERIC(DEFINE_NATIVE_ENTRY_LOAD)
 #undef DEFINE_NATIVE_ENTRY_LOAD

 DEFINE_NATIVE_ENTRY(Ffi_loadPointer, 1, 2) {
   UNREACHABLE();
 }

 static ObjectPtr LoadValueStruct(Zone* zone,
                                  const Pointer& target,
                                  const AbstractType& instance_type_arg) {
   // Result is a struct class -- find <class name>.#fromPointer
   // constructor and call it.
   const Class& cls = Class::Handle(zone, instance_type_arg.type_class());
   const Function& constructor =
       Function::Handle(cls.LookupFunctionAllowPrivate(String::Handle(
           String::Concat(String::Handle(String::Concat(
                              String::Handle(cls.Name()), Symbols::Dot())),
                          Symbols::StructFromPointer()))));
   ASSERT(!constructor.IsNull());
   ASSERT(constructor.IsGenerativeConstructor());
   ASSERT(!Object::Handle(constructor.VerifyCallEntryPoint()).IsError());
   const Instance& new_object = Instance::Handle(Instance::New(cls));
   ASSERT(cls.is_allocated() || Dart::vm_snapshot_kind() != Snapshot::kFullAOT);
   const Array& args = Array::Handle(zone, Array::New(2));
   args.SetAt(0, new_object);
   args.SetAt(1, target);
   const Object& constructorResult =
       Object::Handle(DartEntry::InvokeFunction(constructor, args));
   ASSERT(!constructorResult.IsError());
   return new_object.raw();
 }

 DEFINE_NATIVE_ENTRY(Ffi_loadStruct, 0, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Pointer, pointer, arguments->NativeArgAt(0));
   const AbstractType& pointer_type_arg =
       AbstractType::Handle(pointer.type_argument());
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, index, arguments->NativeArgAt(1));

   // TODO(36370): Make representation consistent with kUnboxedFfiIntPtr.
   const size_t address =
       pointer.NativeAddress() + static_cast<intptr_t>(index.AsInt64Value()) *
                                     SizeOf(zone, pointer_type_arg);
   const Pointer& pointer_offset =
       Pointer::Handle(zone, Pointer::New(pointer_type_arg, address));

   return LoadValueStruct(zone, pointer_offset, pointer_type_arg);
 }

 #define DEFINE_NATIVE_ENTRY_STORE(type)                                        \
   DEFINE_NATIVE_ENTRY(Ffi_store##type, 0, 3) { UNREACHABLE(); }
 CLASS_LIST_FFI_NUMERIC(DEFINE_NATIVE_ENTRY_STORE)
 #undef DEFINE_NATIVE_ENTRY_STORE

 DEFINE_NATIVE_ENTRY(Ffi_storePointer, 0, 3) {
   UNREACHABLE();
 }

 DEFINE_NATIVE_ENTRY(Ffi_sizeOf, 1, 0) {
   GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
   CheckSized(type_arg);

   return Integer::New(SizeOf(zone, type_arg));
 }

 // Static invocations to this method are translated directly in streaming FGB.
 DEFINE_NATIVE_ENTRY(Ffi_asFunctionInternal, 2, 1) {
   UNREACHABLE();
 }

 DEFINE_NATIVE_ENTRY(Ffi_asExternalTypedData, 0, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Pointer, pointer, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, count, arguments->NativeArgAt(1));
   const auto& pointer_type_arg = AbstractType::Handle(pointer.type_argument());
   const classid_t type_cid = pointer_type_arg.type_class_id();
   classid_t cid = 0;

   switch (type_cid) {
     case kFfiInt8Cid:
       cid = kExternalTypedDataInt8ArrayCid;
       break;
     case kFfiUint8Cid:
       cid = kExternalTypedDataUint8ArrayCid;
       break;
     case kFfiInt16Cid:
       cid = kExternalTypedDataInt16ArrayCid;
       break;
     case kFfiUint16Cid:
       cid = kExternalTypedDataUint16ArrayCid;
       break;
     case kFfiInt32Cid:
       cid = kExternalTypedDataInt32ArrayCid;
       break;
     case kFfiUint32Cid:
       cid = kExternalTypedDataUint32ArrayCid;
       break;
     case kFfiInt64Cid:
       cid = kExternalTypedDataInt64ArrayCid;
       break;
     case kFfiUint64Cid:
       cid = kExternalTypedDataUint64ArrayCid;
       break;
     case kFfiIntPtrCid:
       cid = kWordSize == 4 ? kExternalTypedDataInt32ArrayCid
                            : kExternalTypedDataInt64ArrayCid;
       break;
     case kFfiFloatCid:
       cid = kExternalTypedDataFloat32ArrayCid;
       break;
     case kFfiDoubleCid:
       cid = kExternalTypedDataFloat64ArrayCid;
       break;
     default: {
       const String& error = String::Handle(
           String::NewFormatted("Cannot create a TypedData from a Pointer to %s",
                                pointer_type_arg.ToCString()));
       Exceptions::ThrowArgumentError(error);
       UNREACHABLE();
     }
   }

   const intptr_t element_count = count.AsInt64Value();

   if (element_count < 0 ||
       element_count > ExternalTypedData::MaxElements(cid)) {
     const String& error = String::Handle(
         String::NewFormatted("Count must be in the range [0, %" Pd "].",
                              ExternalTypedData::MaxElements(cid)));
     Exceptions::ThrowArgumentError(error);
   }

   // The address must be aligned by the element size.
   const intptr_t element_size = ExternalTypedData::ElementSizeFor(cid);
   if (!Utils::IsAligned(pointer.NativeAddress(), element_size)) {
     const String& error = String::Handle(
         String::NewFormatted("Pointer address must be aligned to a multiple of"
                              "the element size (%" Pd ").",
                              element_size));
     Exceptions::ThrowArgumentError(error);
   }

   const auto& typed_data_class =
       Class::Handle(zone, isolate->class_table()->At(cid));
   const auto& error =
       Error::Handle(zone, typed_data_class.EnsureIsFinalized(thread));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }

   // We disable msan initialization check because the memory may not be
   // initialized yet - dart code might do that later on.
   return ExternalTypedData::New(
       cid, reinterpret_cast<uint8_t*>(pointer.NativeAddress()), element_count,
       Heap::kNew, /*perform_eager_msan_initialization_check=*/false);
 }

 DEFINE_NATIVE_ENTRY(Ffi_nativeCallbackFunction, 1, 2) {
 #if defined(DART_PRECOMPILED_RUNTIME) || defined(DART_PRECOMPILER)
   // Calls to this function are removed by the flow-graph builder in AOT.
   // See StreamingFlowGraphBuilder::BuildFfiNativeCallbackFunction().
   UNREACHABLE();
 #else
   GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Closure, closure, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, exceptional_return,
                                arguments->NativeArgAt(1));

   ASSERT(type_arg.IsInstantiated() && type_arg.IsFunctionType());
   const Function& native_signature =
       Function::Handle(zone, Type::Cast(type_arg).signature());
   Function& func = Function::Handle(zone, closure.function());

   // The FE verifies that the target of a 'fromFunction' is a static method, so
   // the value we see here must be a static tearoff. See ffi_use_sites.dart for
   // details.
   //
   // TODO(36748): Define hot-reload semantics of native callbacks. We may need
   // to look up the target by name.
   ASSERT(func.IsImplicitClosureFunction());
   func = func.parent_function();
   ASSERT(func.is_static());

   // We are returning an object which is not an Instance here. This is only OK
   // because we know that the result will be passed directly to
   // _pointerFromFunction and will not leak out into user code.
   arguments->SetReturn(
       Function::Handle(zone, compiler::ffi::NativeCallbackFunction(
                                  native_signature, func, exceptional_return)));

   // Because we have already set the return value.
   return Object::sentinel().raw();
 #endif
 }

 DEFINE_NATIVE_ENTRY(Ffi_pointerFromFunction, 1, 1) {
   GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
   const Function& function =
       Function::CheckedHandle(zone, arguments->NativeArg0());

   Code& code = Code::Handle(zone);

 #if defined(DART_PRECOMPILED_RUNTIME)
   code = function.CurrentCode();
 #else
   // We compile the callback immediately because we need to return a pointer to
   // the entry-point. Native calls do not use patching like Dart calls, so we
   // cannot compile it lazily.
   const Object& result = Object::Handle(
       zone, Compiler::CompileOptimizedFunction(thread, function));
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
   ASSERT(result.IsCode());
   code ^= result.raw();
 #endif

   ASSERT(!code.IsNull());
   thread->SetFfiCallbackCode(function.FfiCallbackId(), code);

   uword entry_point = code.EntryPoint();
 #if !defined(DART_PRECOMPILED_RUNTIME)
   if (NativeCallbackTrampolines::Enabled()) {
     entry_point = isolate->native_callback_trampolines()->TrampolineForId(
         function.FfiCallbackId());
   }
 #endif

   return Pointer::New(type_arg, entry_point);
 }

 DEFINE_NATIVE_ENTRY(DartNativeApiFunctionPointer, 0, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(String, name_dart, arguments->NativeArgAt(0));
   const char* name = name_dart.ToCString();

 #define RETURN_FUNCTION_ADDRESS(function_name, R, A)                           \
   if (strcmp(name, #function_name) == 0) {                                     \
     return Integer::New(reinterpret_cast<intptr_t>(function_name));            \
   }
   DART_NATIVE_API_DL_SYMBOLS(RETURN_FUNCTION_ADDRESS)
 #undef RETURN_FUNCTION_ADDRESS

   const String& error = String::Handle(
       String::NewFormatted("Unknown dart_native_api.h symbol: %s.", name));
   Exceptions::ThrowArgumentError(error);
 }

 DEFINE_NATIVE_ENTRY(DartApiDLMajorVersion, 0, 0) {
   return Integer::New(DART_API_DL_MAJOR_VERSION);
 }

 DEFINE_NATIVE_ENTRY(DartApiDLMinorVersion, 0, 0) {
   return Integer::New(DART_API_DL_MINOR_VERSION);
 }

 static const DartApiEntry dart_api_entries[] = {
 #define ENTRY(name, R, A)                                                      \
   DartApiEntry{#name, reinterpret_cast<void (*)()>(name)},
     DART_API_ALL_DL_SYMBOLS(ENTRY)
 #undef ENTRY
         DartApiEntry{nullptr, nullptr}};

 static const DartApi dart_api_data = {
     DART_API_DL_MAJOR_VERSION, DART_API_DL_MINOR_VERSION, dart_api_entries};

 DEFINE_NATIVE_ENTRY(DartApiDLInitializeData, 0, 0) {
   return Integer::New(reinterpret_cast<intptr_t>(&dart_api_data));
 }

 }  // namespace dart
	// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	#include "include/dart_api.h"
	#include "include/dart_api_dl.h"
	#include "include/dart_native_api.h"
	#include "include/dart_version.h"
	#include "include/internal/dart_api_dl_impl.h"
	#include "platform/globals.h"
	#include "vm/bootstrap_natives.h"
	#include "vm/class_finalizer.h"
	#include "vm/class_id.h"
	#include "vm/compiler/ffi/native_type.h"
	#include "vm/exceptions.h"
	#include "vm/flags.h"
	#include "vm/log.h"
	#include "vm/native_arguments.h"
	#include "vm/native_entry.h"
	#include "vm/object.h"
	#include "vm/object_store.h"
	#include "vm/symbols.h"

	#if !defined(DART_PRECOMPILED_RUNTIME)
	#include "vm/compiler/assembler/assembler.h"
	#include "vm/compiler/ffi/call.h"
	#include "vm/compiler/ffi/callback.h"
	#include "vm/compiler/jit/compiler.h"
	#endif // !defined(DART_PRECOMPILED_RUNTIME)

	namespace dart {

	// The following functions are runtime checks on type arguments.
	// Some checks are also performed in kernel transformation, these are asserts.
	// Some checks are only performed at runtime to allow for generic code, these
	// throw ArgumentExceptions.

	static void CheckSized(const AbstractType& type_arg) {
	const classid_t type_cid = type_arg.type_class_id();
	if (IsFfiNativeTypeTypeClassId(type_cid) \|\| IsFfiTypeVoidClassId(type_cid) \|\|
	IsFfiTypeNativeFunctionClassId(type_cid)) {
	const String& error = String::Handle(String::NewFormatted(
	"%s does not have a predefined size (@unsized). "
	"Unsized NativeTypes do not support [sizeOf] because their size "
	"is unknown. "
	"Consequently, [allocate], [Pointer.load], [Pointer.store], and "
	"[Pointer.elementAt] are not available.",
	String::Handle(type_arg.UserVisibleName()).ToCString()));
	Exceptions::ThrowArgumentError(error);
	}
	}

	// Calculate the size of a native type.
	//
	// You must check [IsConcreteNativeType] and [CheckSized] first to verify that
	// this type has a defined size.
	static size_t SizeOf(Zone* zone, const AbstractType& type) {
	if (IsFfiTypeClassId(type.type_class_id())) {
	return compiler::ffi::NativeType::FromAbstractType(zone, type)
	.SizeInBytes();
	} else {
	Class& struct_class = Class::Handle(type.type_class());
	Object& result = Object::Handle(
	struct_class.InvokeGetter(Symbols::SizeOfStructField(),
	/throw_nsm_if_absent=/false,
	/respect_reflectable=/false));
	ASSERT(!result.IsNull() && result.IsInteger());
	return Integer::Cast(result).AsInt64Value();
	}
	}

	// The remainder of this file implements the dart:ffi native methods.

	DEFINE_NATIVE_ENTRY(Ffi_fromAddress, 1, 1) {
	UNREACHABLE();
	}

	DEFINE_NATIVE_ENTRY(Ffi_address, 0, 1) {
	UNREACHABLE();
	}

	#define DEFINE_NATIVE_ENTRY_LOAD(type) \
	DEFINE_NATIVE_ENTRY(Ffi_load##type, 0, 2) { UNREACHABLE(); }
	CLASS_LIST_FFI_NUMERIC(DEFINE_NATIVE_ENTRY_LOAD)
	#undef DEFINE_NATIVE_ENTRY_LOAD

	DEFINE_NATIVE_ENTRY(Ffi_loadPointer, 1, 2) {
	UNREACHABLE();
	}

	static ObjectPtr LoadValueStruct(Zone* zone,
	const Pointer& target,
	const AbstractType& instance_type_arg) {
	// Result is a struct class -- find <class name>.#fromPointer
	// constructor and call it.
	const Class& cls = Class::Handle(zone, instance_type_arg.type_class());
	const Function& constructor =
	Function::Handle(cls.LookupFunctionAllowPrivate(String::Handle(
	String::Concat(String::Handle(String::Concat(
	String::Handle(cls.Name()), Symbols::Dot())),
	Symbols::StructFromPointer()))));
	ASSERT(!constructor.IsNull());
	ASSERT(constructor.IsGenerativeConstructor());
	ASSERT(!Object::Handle(constructor.VerifyCallEntryPoint()).IsError());
	const Instance& new_object = Instance::Handle(Instance::New(cls));
	ASSERT(cls.is_allocated() \|\| Dart::vm_snapshot_kind() != Snapshot::kFullAOT);
	const Array& args = Array::Handle(zone, Array::New(2));
	args.SetAt(0, new_object);
	args.SetAt(1, target);
	const Object& constructorResult =
	Object::Handle(DartEntry::InvokeFunction(constructor, args));
	ASSERT(!constructorResult.IsError());
	return new_object.raw();
	}

	DEFINE_NATIVE_ENTRY(Ffi_loadStruct, 0, 2) {
	GET_NON_NULL_NATIVE_ARGUMENT(Pointer, pointer, arguments->NativeArgAt(0));
	const AbstractType& pointer_type_arg =
	AbstractType::Handle(pointer.type_argument());
	GET_NON_NULL_NATIVE_ARGUMENT(Integer, index, arguments->NativeArgAt(1));

	// TODO(36370): Make representation consistent with kUnboxedFfiIntPtr.
	const size_t address =
	pointer.NativeAddress() + static_cast<intptr_t>(index.AsInt64Value()) *
	SizeOf(zone, pointer_type_arg);
	const Pointer& pointer_offset =
	Pointer::Handle(zone, Pointer::New(pointer_type_arg, address));

	return LoadValueStruct(zone, pointer_offset, pointer_type_arg);
	}

	#define DEFINE_NATIVE_ENTRY_STORE(type) \
	DEFINE_NATIVE_ENTRY(Ffi_store##type, 0, 3) { UNREACHABLE(); }
	CLASS_LIST_FFI_NUMERIC(DEFINE_NATIVE_ENTRY_STORE)
	#undef DEFINE_NATIVE_ENTRY_STORE

	DEFINE_NATIVE_ENTRY(Ffi_storePointer, 0, 3) {
	UNREACHABLE();
	}

	DEFINE_NATIVE_ENTRY(Ffi_sizeOf, 1, 0) {
	GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
	CheckSized(type_arg);

	return Integer::New(SizeOf(zone, type_arg));
	}

	// Static invocations to this method are translated directly in streaming FGB.
	DEFINE_NATIVE_ENTRY(Ffi_asFunctionInternal, 2, 1) {
	UNREACHABLE();
	}

	DEFINE_NATIVE_ENTRY(Ffi_asExternalTypedData, 0, 2) {
	GET_NON_NULL_NATIVE_ARGUMENT(Pointer, pointer, arguments->NativeArgAt(0));
	GET_NON_NULL_NATIVE_ARGUMENT(Integer, count, arguments->NativeArgAt(1));
	const auto& pointer_type_arg = AbstractType::Handle(pointer.type_argument());
	const classid_t type_cid = pointer_type_arg.type_class_id();
	classid_t cid = 0;

	switch (type_cid) {
	case kFfiInt8Cid:
	cid = kExternalTypedDataInt8ArrayCid;
	break;
	case kFfiUint8Cid:
	cid = kExternalTypedDataUint8ArrayCid;
	break;
	case kFfiInt16Cid:
	cid = kExternalTypedDataInt16ArrayCid;
	break;
	case kFfiUint16Cid:
	cid = kExternalTypedDataUint16ArrayCid;
	break;
	case kFfiInt32Cid:
	cid = kExternalTypedDataInt32ArrayCid;
	break;
	case kFfiUint32Cid:
	cid = kExternalTypedDataUint32ArrayCid;
	break;
	case kFfiInt64Cid:
	cid = kExternalTypedDataInt64ArrayCid;
	break;
	case kFfiUint64Cid:
	cid = kExternalTypedDataUint64ArrayCid;
	break;
	case kFfiIntPtrCid:
	cid = kWordSize == 4 ? kExternalTypedDataInt32ArrayCid
	: kExternalTypedDataInt64ArrayCid;
	break;
	case kFfiFloatCid:
	cid = kExternalTypedDataFloat32ArrayCid;
	break;
	case kFfiDoubleCid:
	cid = kExternalTypedDataFloat64ArrayCid;
	break;
	default: {
	const String& error = String::Handle(
	String::NewFormatted("Cannot create a TypedData from a Pointer to %s",
	pointer_type_arg.ToCString()));
	Exceptions::ThrowArgumentError(error);
	UNREACHABLE();
	}
	}

	const intptr_t element_count = count.AsInt64Value();

	if (element_count < 0 \|\|
	element_count > ExternalTypedData::MaxElements(cid)) {
	const String& error = String::Handle(
	String::NewFormatted("Count must be in the range [0, %" Pd "].",
	ExternalTypedData::MaxElements(cid)));
	Exceptions::ThrowArgumentError(error);
	}

	// The address must be aligned by the element size.
	const intptr_t element_size = ExternalTypedData::ElementSizeFor(cid);
	if (!Utils::IsAligned(pointer.NativeAddress(), element_size)) {
	const String& error = String::Handle(
	String::NewFormatted("Pointer address must be aligned to a multiple of"
	"the element size (%" Pd ").",
	element_size));
	Exceptions::ThrowArgumentError(error);
	}

	const auto& typed_data_class =
	Class::Handle(zone, isolate->class_table()->At(cid));
	const auto& error =
	Error::Handle(zone, typed_data_class.EnsureIsFinalized(thread));
	if (!error.IsNull()) {
	Exceptions::PropagateError(error);
	}

	// We disable msan initialization check because the memory may not be
	// initialized yet - dart code might do that later on.
	return ExternalTypedData::New(
	cid, reinterpret_cast<uint8_t*>(pointer.NativeAddress()), element_count,
	Heap::kNew, /perform_eager_msan_initialization_check=/false);
	}

	DEFINE_NATIVE_ENTRY(Ffi_nativeCallbackFunction, 1, 2) {
	#if defined(DART_PRECOMPILED_RUNTIME) \|\| defined(DART_PRECOMPILER)
	// Calls to this function are removed by the flow-graph builder in AOT.
	// See StreamingFlowGraphBuilder::BuildFfiNativeCallbackFunction().
	UNREACHABLE();
	#else
	GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
	GET_NON_NULL_NATIVE_ARGUMENT(Closure, closure, arguments->NativeArgAt(0));
	GET_NON_NULL_NATIVE_ARGUMENT(Instance, exceptional_return,
	arguments->NativeArgAt(1));

	ASSERT(type_arg.IsInstantiated() && type_arg.IsFunctionType());
	const Function& native_signature =
	Function::Handle(zone, Type::Cast(type_arg).signature());
	Function& func = Function::Handle(zone, closure.function());

	// The FE verifies that the target of a 'fromFunction' is a static method, so
	// the value we see here must be a static tearoff. See ffi_use_sites.dart for
	// details.
	//
	// TODO(36748): Define hot-reload semantics of native callbacks. We may need
	// to look up the target by name.
	ASSERT(func.IsImplicitClosureFunction());
	func = func.parent_function();
	ASSERT(func.is_static());

	// We are returning an object which is not an Instance here. This is only OK
	// because we know that the result will be passed directly to
	// _pointerFromFunction and will not leak out into user code.
	arguments->SetReturn(
	Function::Handle(zone, compiler::ffi::NativeCallbackFunction(
	native_signature, func, exceptional_return)));

	// Because we have already set the return value.
	return Object::sentinel().raw();
	#endif
	}

	DEFINE_NATIVE_ENTRY(Ffi_pointerFromFunction, 1, 1) {
	GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
	const Function& function =
	Function::CheckedHandle(zone, arguments->NativeArg0());

	Code& code = Code::Handle(zone);

	#if defined(DART_PRECOMPILED_RUNTIME)
	code = function.CurrentCode();
	#else
	// We compile the callback immediately because we need to return a pointer to
	// the entry-point. Native calls do not use patching like Dart calls, so we
	// cannot compile it lazily.
	const Object& result = Object::Handle(
	zone, Compiler::CompileOptimizedFunction(thread, function));
	if (result.IsError()) {
	Exceptions::PropagateError(Error::Cast(result));
	}
	ASSERT(result.IsCode());
	code ^= result.raw();
	#endif

	ASSERT(!code.IsNull());
	thread->SetFfiCallbackCode(function.FfiCallbackId(), code);

	uword entry_point = code.EntryPoint();
	#if !defined(DART_PRECOMPILED_RUNTIME)
	if (NativeCallbackTrampolines::Enabled()) {
	entry_point = isolate->native_callback_trampolines()->TrampolineForId(
	function.FfiCallbackId());
	}
	#endif

	return Pointer::New(type_arg, entry_point);
	}

	DEFINE_NATIVE_ENTRY(DartNativeApiFunctionPointer, 0, 1) {
	GET_NON_NULL_NATIVE_ARGUMENT(String, name_dart, arguments->NativeArgAt(0));
	const char* name = name_dart.ToCString();

	#define RETURN_FUNCTION_ADDRESS(function_name, R, A) \
	if (strcmp(name, #function_name) == 0) { \
	return Integer::New(reinterpret_cast<intptr_t>(function_name)); \
	}
	DART_NATIVE_API_DL_SYMBOLS(RETURN_FUNCTION_ADDRESS)
	#undef RETURN_FUNCTION_ADDRESS

	const String& error = String::Handle(
	String::NewFormatted("Unknown dart_native_api.h symbol: %s.", name));
	Exceptions::ThrowArgumentError(error);
	}

	DEFINE_NATIVE_ENTRY(DartApiDLMajorVersion, 0, 0) {
	return Integer::New(DART_API_DL_MAJOR_VERSION);
	}

	DEFINE_NATIVE_ENTRY(DartApiDLMinorVersion, 0, 0) {
	return Integer::New(DART_API_DL_MINOR_VERSION);
	}

	static const DartApiEntry dart_api_entries[] = {
	#define ENTRY(name, R, A) \
	DartApiEntry{#name, reinterpret_cast<void (*)()>(name)},
	DART_API_ALL_DL_SYMBOLS(ENTRY)
	#undef ENTRY
	DartApiEntry{nullptr, nullptr}};

	static const DartApi dart_api_data = {
	DART_API_DL_MAJOR_VERSION, DART_API_DL_MINOR_VERSION, dart_api_entries};

	DEFINE_NATIVE_ENTRY(DartApiDLInitializeData, 0, 0) {
	return Integer::New(reinterpret_cast<intptr_t>(&dart_api_data));
	}

	} // namespace dart