blob: cc4a6ff5203c5e599418580150d6e35b66aa1104 [file] [log] [blame]
// 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/dart_api_impl.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 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();
}
DEFINE_NATIVE_ENTRY(Ffi_loadStruct, 0, 2) {
UNREACHABLE();
}
#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();
}
// Static invocations to this method are translated directly in streaming FGB.
DEFINE_NATIVE_ENTRY(Ffi_asFunctionInternal, 2, 2) {
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->group()->class_table()->At(cid));
const auto& error =
Error::Handle(zone, typed_data_class.EnsureIsAllocateFinalized(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 FunctionType& native_signature = FunctionType::Cast(type_arg);
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().ptr();
#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.ptr();
#endif
ASSERT(!code.IsNull());
thread->SetFfiCallbackCode(function.FfiCallbackId(), code);
#ifdef TARGET_ARCH_IA32
// On ia32, store the stack delta that we need to use when returning.
const intptr_t stack_return_delta =
function.FfiCSignatureReturnsStruct() && CallingConventions::kUsesRet4
? compiler::target::kWordSize
: 0;
thread->SetFfiCallbackStackReturn(function.FfiCallbackId(),
stack_return_delta);
#endif
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));
}
// FFI native C function pointer resolver.
static intptr_t FfiResolve(Dart_Handle lib_url, Dart_Handle name) {
DARTSCOPE(Thread::Current());
const String& lib_url_str = Api::UnwrapStringHandle(T->zone(), lib_url);
const String& function_name = Api::UnwrapStringHandle(T->zone(), name);
// Find the corresponding library's native function resolver (if set).
const Library& lib = Library::Handle(Library::LookupLibrary(T, lib_url_str));
if (lib.IsNull()) {
const String& error = String::Handle(String::NewFormatted(
"Unknown library: '%s'.", lib_url_str.ToCString()));
Exceptions::ThrowArgumentError(error);
}
auto resolver = lib.ffi_native_resolver();
if (resolver == nullptr) {
const String& error = String::Handle(String::NewFormatted(
"Library has no handler: '%s'.", lib_url_str.ToCString()));
Exceptions::ThrowArgumentError(error);
}
auto* f = resolver(function_name.ToCString());
if (f == nullptr) {
const String& error = String::Handle(String::NewFormatted(
"Couldn't resolve function: '%s'.", function_name.ToCString()));
Exceptions::ThrowArgumentError(error);
}
return reinterpret_cast<intptr_t>(f);
}
// Bootstrap to get the FFI Native resolver through a `native` call.
DEFINE_NATIVE_ENTRY(Ffi_GetFfiNativeResolver, 1, 0) {
GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
return Pointer::New(type_arg, reinterpret_cast<intptr_t>(FfiResolve));
}
} // namespace dart