#include <marshaller.h>

Inheritance diagram for dart::compiler::ffi::CallbackMarshaller:

Public Member Functions
	CallbackMarshaller (Zone *zone, const Function &dart_signature, const FunctionType &c_signature, const NativeCallingConvention &native_calling_convention, const NativeLocations &callback_locs)

virtual Representation	RepInFfiCall (intptr_t def_index_global) const

virtual intptr_t	NumDefinitions (intptr_t arg_index) const

virtual intptr_t	NumReturnDefinitions () const

const NativeLocation &	NativeLocationOfNativeParameter (intptr_t def_index) const

dart::Location	LocationOfNativeParameter (intptr_t def_index) const

Public Member Functions inherited from dart::compiler::ffi::BaseMarshaller
intptr_t	num_args () const

intptr_t	NumArgumentDefinitions () const

bool	ArgumentIndexIsReturn (intptr_t arg_index) const

bool	DefinitionIndexIsReturn (intptr_t def_index_global) const

intptr_t	ArgumentIndex (intptr_t def_index_global) const

intptr_t	FirstDefinitionIndex (intptr_t arg_index) const

intptr_t	DefinitionInArgument (intptr_t def_index_global, intptr_t arg_index) const

intptr_t	DefinitionIndex (intptr_t def_index_in_arg, intptr_t arg_index) const

const NativeLocation &	Location (intptr_t arg_index) const

Representation	RepInDart (intptr_t arg_index) const

void	RepsInFfiCall (intptr_t arg_index, GrowableArray< Representation > *out) const

bool	RequiresBitCast (intptr_t index) const

const NativeType &	SignExtendFrom (intptr_t arg_index) const

AbstractTypePtr	CType (intptr_t arg_index) const

AbstractTypePtr	DartType (intptr_t arg_index) const

bool	IsPointerPointer (intptr_t arg_index) const

bool	IsTypedDataPointer (intptr_t arg_index) const

bool	IsCompoundPointer (intptr_t arg_index) const

bool	IsHandleCType (intptr_t arg_index) const

bool	IsBool (intptr_t arg_index) const

bool	IsCompoundCType (intptr_t arg_index) const

bool	IsVoid (intptr_t arg_index) const

bool	ContainsHandles () const

bool	contains_varargs () const

const Function &	dart_signature () const

intptr_t	dart_signature_params_start_at () const

const FunctionType &	c_signature () const

StringPtr	function_name () const

Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()

void *	operator new (size_t size)

void *	operator new (size_t size, Zone *zone)

void	operator delete (void *pointer)

Static Public Member Functions
static CallbackMarshaller *	FromFunction (Zone zone, const Function &function, const char *error)

Protected Member Functions
	~CallbackMarshaller ()

Protected Member Functions inherited from dart::compiler::ffi::BaseMarshaller
bool	IsPointerDartType (intptr_t arg_index) const

bool	IsPointerCType (intptr_t arg_index) const

	BaseMarshaller (Zone *zone, const Function &dart_signature, intptr_t dart_signature_params_start_at, const FunctionType &c_signature, const NativeCallingConvention &native_calling_convention)

	~BaseMarshaller ()

Protected Attributes
const NativeLocations &	callback_locs_

Protected Attributes inherited from dart::compiler::ffi::BaseMarshaller
Zone *	zone_

const Function &	dart_signature_

const intptr_t	dart_signature_params_start_at_

const FunctionType &	c_signature_

const NativeCallingConvention &	native_calling_convention_

Detailed Description

Definition at line 243 of file marshaller.h.

Constructor & Destructor Documentation

◆ CallbackMarshaller()

dart::compiler::ffi::CallbackMarshaller::CallbackMarshaller	(	Zone *	zone,
		const Function &	dart_signature,
		const FunctionType &	c_signature,
		const NativeCallingConvention &	native_calling_convention,
		const NativeLocations &	callback_locs
	)

inline

Definition at line 249 of file marshaller.h.

      : BaseMarshaller(zone,
                       dart_signature,
                       /*dart_signature_params_start_at=*/0,
                       c_signature,
                       native_calling_convention),
        callback_locs_(callback_locs) {}

◆ ~CallbackMarshaller()

dart::compiler::ffi::CallbackMarshaller::~CallbackMarshaller ( )

inlineprotected

Definition at line 280 of file marshaller.h.

280{}

Member Function Documentation

◆ FromFunction()

CallbackMarshaller * dart::compiler::ffi::CallbackMarshaller::FromFunction	(	Zone *	zone,
		const Function &	function,
		const char **	error
	)

static

Definition at line 879 of file marshaller.cc.

                                                                         {
  DEBUG_ASSERT(function.IsNotTemporaryScopedHandle());
  const auto& c_signature =
      FunctionType::ZoneHandle(zone, function.FfiCSignature());
  const auto native_function_signature =
      NativeFunctionTypeFromFunctionType(zone, c_signature, error);
  if (*error != nullptr) {
    return nullptr;
  }
  const auto& native_calling_convention =
      NativeCallingConvention::FromSignature(zone, *native_function_signature);
  const auto& callback_locs =
      CallbackArgumentTranslator::TranslateArgumentLocations(
          zone, native_calling_convention.argument_locations(),
          native_calling_convention.return_location());
  return new (zone) CallbackMarshaller(
      zone, function, c_signature, native_calling_convention, callback_locs);
}

◆ LocationOfNativeParameter()

dart::Location dart::compiler::ffi::CallbackMarshaller::LocationOfNativeParameter ( intptr_t def_index ) const

inline

Definition at line 271 of file marshaller.h.

                                                                   {
    const auto& native_loc = NativeLocationOfNativeParameter(def_index);
    if (native_loc.IsPointerToMemory()) {
      return native_loc.AsPointerToMemory().pointer_location().AsLocation();
    }
    return native_loc.AsLocation();
  }

◆ NativeLocationOfNativeParameter()

const NativeLocation & dart::compiler::ffi::CallbackMarshaller::NativeLocationOfNativeParameter ( intptr_t def_index ) const

Definition at line 900 of file marshaller.cc.

                              {
  const intptr_t arg_index = ArgumentIndex(def_index);
  if (arg_index == kResultIndex) {
    const auto& result_loc = Location(arg_index);
    if (result_loc.IsPointerToMemory()) {
      // If it's a pointer we return it in the last.
      return *callback_locs_.At(callback_locs_.length() - 1);
    }
    // The other return types are not translated.
    return result_loc;
  }
 
  // Check that we only have stack arguments.
  const auto& loc = *callback_locs_.At(arg_index);
  ASSERT(loc.IsStack() || loc.IsPointerToMemory() || loc.IsMultiple());
  if (loc.IsStack()) {
    ASSERT(loc.AsStack().base_register() == SPREG);
    if (loc.payload_type().IsPrimitive()) {
      return loc;
    }
    const intptr_t index = DefinitionInArgument(def_index, arg_index);
    const intptr_t count = NumDefinitions(arg_index);
    return loc.Split(zone_, count, index);
  } else if (loc.IsPointerToMemory()) {
    const auto& pointer_loc = loc.AsPointerToMemory().pointer_location();
    ASSERT(pointer_loc.IsStack() &&
           pointer_loc.AsStack().base_register() == SPREG);
    return loc;
  }
  const auto& multiple = loc.AsMultiple();
  const intptr_t index = DefinitionInArgument(def_index, arg_index);
  const auto& multi_loc = *multiple.locations().At(index);
  ASSERT(multi_loc.IsStack() && multi_loc.AsStack().base_register() == SPREG);
  return multi_loc;
}

◆ NumDefinitions()

intptr_t dart::compiler::ffi::CallbackMarshaller::NumDefinitions ( intptr_t arg_index ) const

virtual

Reimplemented from dart::compiler::ffi::BaseMarshaller.

Definition at line 306 of file marshaller.cc.

                                                                    {
  if (!ArgumentIndexIsReturn(arg_index)) {
    const auto& loc = Location(arg_index);
    const auto& type = loc.payload_type();
    if (type.IsCompound() && loc.IsPointerToMemory()) {
      // For FFI callbacks, get the pointer in a NativeParameter and construct
      // the TypedDataBase in IL (always offset in bytes 0).
      return 1;
    }
  }
  return BaseMarshaller::NumDefinitions(arg_index);
}

◆ NumReturnDefinitions()

intptr_t dart::compiler::ffi::CallbackMarshaller::NumReturnDefinitions ( ) const

virtual

Implements dart::compiler::ffi::BaseMarshaller.

Definition at line 331 of file marshaller.cc.

                                                        {
  const auto& loc = Location(kResultIndex);
 
  if (loc.IsMultiple()) {
    const auto& type = loc.payload_type();
    ASSERT(type.IsCompound());
    // For multiple locations, some native locations cannot be expressed as
    // Locations, which means the flow graph builder cannot generate appropriate
    // IL for those cases.
    //
    // Instead, the flow graph builder generates IL to extract the
    // _typedDataBase and _offsetInBytes fields of the Dart value and passes
    // those into the NativeReturn instruction as separate arguments. The
    // generated machine code for the NativeReturn instruction then
    // appropriately copies the contents to a non-GC-managed block of memory. A
    // pointer to that block of memory is returned to the C code.
    return 2;
  }
 
  // If it's a compound and the native ABI is passing a pointer, copy to it in
  // IL. If non-compound, also 1 definition. If it's a primitive, the flow graph
  // builder generates IL to create an appropriate Dart value from the single
  // value returned from C.
  return 1;
}

◆ RepInFfiCall()

Representation dart::compiler::ffi::CallbackMarshaller::RepInFfiCall ( intptr_t def_index_global ) const

virtual

Reimplemented from dart::compiler::ffi::BaseMarshaller.

Definition at line 523 of file marshaller.cc.

                                     {
  intptr_t arg_index = ArgumentIndex(def_index_global);
  if (IsHandleCType(arg_index)) {
    // Dart objects are passed to C as untagged pointers to newly created
    // handles in the IL, and the ptr field of untagged pointers to handles are
    // extracted when the IL receives handles from C code.
    return kUntagged;
  }
  const auto& location = Location(arg_index);
  if (location.IsPointerToMemory()) {
    // The IL gets an untagged pointer to memory both for arguments and for
    // returns. If this is an argument, then the IL creates a Dart
    // representation of the compound object from the pointed at memory.
    // For returns, the IL copies the data from the compound object into
    // the memory being pointed at before returning to C.
    return kUntagged;
  }
  if (ArgumentIndexIsReturn(arg_index) && location.IsMultiple()) {
    // To return a compound object broken up over multiple native locations,
    // the IL loads the compound object into a single TypedData object and
    // passes that TypedData object to NativeReturn, which handles extracting
    // the data to the appropriate native locations.
    return kTagged;
  }
  return BaseMarshaller::RepInFfiCall(def_index_global);
}

Member Data Documentation

◆ callback_locs_

const NativeLocations& dart::compiler::ffi::CallbackMarshaller::callback_locs_

protected

Definition at line 282 of file marshaller.h.

The documentation for this class was generated from the following files:

third_party/dart-lang/sdk/runtime/vm/compiler/ffi/marshaller.h
third_party/dart-lang/sdk/runtime/vm/compiler/ffi/marshaller.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CallbackMarshaller()

◆ ~CallbackMarshaller()

Member Function Documentation

◆ FromFunction()

◆ LocationOfNativeParameter()

◆ NativeLocationOfNativeParameter()

◆ NumDefinitions()

◆ NumReturnDefinitions()

◆ RepInFfiCall()

Member Data Documentation

◆ callback_locs_