#include <marshaller.h>

Inheritance diagram for dart::compiler::ffi::CallMarshaller:

Public Member Functions
	CallMarshaller (Zone *zone, const Function &dart_signature, intptr_t dart_signature_params_start_at, const FunctionType &c_signature, const NativeCallingConvention &native_calling_convention)

virtual intptr_t	NumDefinitions (intptr_t arg_index) const

virtual intptr_t	NumReturnDefinitions () const

virtual Representation	RepInFfiCall (intptr_t def_index_global) const

dart::Location	LocInFfiCall (intptr_t def_index_global) const

bool	ReturnsCompound () const

intptr_t	CompoundReturnSizeInBytes () const

intptr_t	PassByPointerStackOffset (intptr_t arg_index) const

intptr_t	RequiredStackSpaceInBytes () 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 CallMarshaller *	FromFunction (Zone zone, const Function &function, intptr_t function_params_start_at, const FunctionType &c_signature, const char *error)

Protected Member Functions
	~CallMarshaller ()

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 ()

Additional Inherited Members
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 198 of file marshaller.h.

Constructor & Destructor Documentation

◆ CallMarshaller()

dart::compiler::ffi::CallMarshaller::CallMarshaller	(	Zone *	zone,
		const Function &	dart_signature,
		intptr_t	dart_signature_params_start_at,
		const FunctionType &	c_signature,
		const NativeCallingConvention &	native_calling_convention
	)

inline

Definition at line 206 of file marshaller.h.

      : BaseMarshaller(zone,
                       dart_signature,
                       dart_signature_params_start_at,
                       c_signature,
                       native_calling_convention) {}

◆ ~CallMarshaller()

dart::compiler::ffi::CallMarshaller::~CallMarshaller ( )

inlineprotected

Definition at line 240 of file marshaller.h.

240{}

Member Function Documentation

◆ CompoundReturnSizeInBytes()

intptr_t dart::compiler::ffi::CallMarshaller::CompoundReturnSizeInBytes ( ) const

Definition at line 684 of file marshaller.cc.

                                                         {
  ASSERT(ReturnsCompound());
  return Utils::RoundUp(
      Location(compiler::ffi::kResultIndex).payload_type().SizeInBytes(),
      compiler::target::kWordSize);
}

◆ FromFunction()

CallMarshaller * dart::compiler::ffi::CallMarshaller::FromFunction	(	Zone *	zone,
		const Function &	function,
		intptr_t	function_params_start_at,
		const FunctionType &	c_signature,
		const char **	error
	)

static

Definition at line 90 of file marshaller.cc.

                                                                 {
  DEBUG_ASSERT(function.IsNotTemporaryScopedHandle());
  DEBUG_ASSERT(c_signature.IsNotTemporaryScopedHandle());
  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);
  return new (zone) CallMarshaller(zone, function, function_params_start_at,
                                   c_signature, native_calling_convention);
}

◆ LocInFfiCall()

Location dart::compiler::ffi::CallMarshaller::LocInFfiCall ( intptr_t def_index_global ) const

Definition at line 600 of file marshaller.cc.

                                                                     {
  const intptr_t arg_index = ArgumentIndex(def_index_global);
  const NativeLocation& loc = this->Location(arg_index);
 
  if (ArgumentIndexIsReturn(arg_index)) {
    if (loc.IsRegisters() || loc.IsFpuRegisters()) {
      return loc.AsLocation();
    }
    ASSERT(ReturnsCompound());
    // No location at all, because we store into TypedData passed to the
    // FfiCall instruction. But we have to supply a location.
    return Location::RegisterLocation(CallingConventions::kReturnReg);
  }
 
  // Force all handles to be Stack locations.
  if (IsHandleCType(arg_index)) {
    return Location::RequiresStack();
  }
 
  if (loc.IsMultiple()) {
    const intptr_t def_index_in_arg =
        def_index_global - FirstDefinitionIndex(arg_index);
    const auto& def_loc = *(loc.AsMultiple().locations()[def_index_in_arg]);
    if (def_loc.IsStack()) {
      // Don't pin stack locations, they need to be moved anyway.
      return ConvertToAnyLocation(def_loc.AsStack(),
                                  RepInFfiCall(def_index_global));
    }
 
    if (def_loc.IsFpuRegisters()) {
      return SelectFpuLocationInIL(zone_, def_loc);
    }
 
    return def_loc.AsLocation();
  }
 
  if (loc.IsPointerToMemory()) {
    const intptr_t def_index_in_arg =
        def_index_global - FirstDefinitionIndex(arg_index);
    if (def_index_in_arg == kTypedDataBaseIndex) {
      const auto& pointer_location = loc.AsPointerToMemory().pointer_location();
      if (pointer_location.IsStack()) {
        // Don't pin stack locations, they need to be moved anyway.
        return ConvertToAnyLocation(pointer_location.AsStack(),
                                    RepInFfiCall(def_index_global));
      }
      return pointer_location.AsLocation();
    } else {
      ASSERT_EQUAL(def_index_in_arg, kOffsetInBytesIndex);
      return Location::Any();
    }
  }
 
  if (IsCompoundPointer(arg_index)) {
    const intptr_t def_index_in_arg =
        def_index_global - FirstDefinitionIndex(arg_index);
    if (def_index_in_arg == kOffsetInBytesIndex) {
      // The typed data is passed in the location from the calling convention.
      // The offset in bytes can be passed in any location.
      return Location::Any();
    }
  }
 
  if (loc.IsStack()) {
    return ConvertToAnyLocation(loc.AsStack(), RepInFfiCall(def_index_global));
  }
 
  if (loc.IsFpuRegisters()) {
    return SelectFpuLocationInIL(zone_, loc);
  }
 
  if (loc.IsBoth()) {
    const auto& fpu_reg_loc = loc.AsBoth().location(0).AsFpuRegisters();
    return SelectFpuLocationInIL(zone_, fpu_reg_loc);
  }
 
  ASSERT(loc.IsRegisters());
  return loc.AsLocation();
}

◆ NumDefinitions()

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

virtual

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

Definition at line 293 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 calls, pass in TypedDataBase and offsetInBytes in IL, and copy
      // contents to stack and pass pointer in right location in MC.
      return 2;
    }
  }
  return BaseMarshaller::NumDefinitions(arg_index);
}

◆ NumReturnDefinitions()

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

virtual

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

Definition at line 319 of file marshaller.cc.

                                                    {
  // An FFICall is a Definition, and Definitions currently only have one
  // return value.
  //
  // For compound returns, the IL generated by the flow graph builder allocates
  // a TypedDataBase object that is passed into the FfiCall. The generated
  // machine code for the FfiCall instruction then fills in the contents.
  // After the call, the generated IL wraps the TypedDataBase object in a
  // Compound object with an offset in bytes of 0.
  return 1;
}

◆ PassByPointerStackOffset()

intptr_t dart::compiler::ffi::CallMarshaller::PassByPointerStackOffset ( intptr_t arg_index ) const

Definition at line 695 of file marshaller.cc.

                                                                          {
  ASSERT(arg_index == kResultIndex ||
         (arg_index >= 0 && arg_index < num_args()) ||
         arg_index == kAfterLastArgumentIndex);
 
  intptr_t stack_offset = 0;
 
  // First the native arguments are on the stack.
  // This is governed by the native ABI, the rest we can chose freely.
  stack_offset += native_calling_convention_.StackTopInBytes();
#if (defined(DART_TARGET_OS_MACOS_IOS) || defined(DART_TARGET_OS_MACOS)) &&    \
    defined(TARGET_ARCH_ARM64)
  // Add extra padding for possibly non stack-aligned word-size writes.
  // TODO(https://dartbug.com/48806): Re-engineer the moves to not over-
  // approximate struct sizes on stack.
  stack_offset += 4;
#endif
  stack_offset = Utils::RoundUp(stack_offset, compiler::target::kWordSize);
  if (arg_index == kResultIndex) {
    return stack_offset;
  }
 
  // Then save space for the result.
  const auto& result_location = Location(compiler::ffi::kResultIndex);
  if (result_location.IsPointerToMemory()) {
    stack_offset += result_location.payload_type().SizeInBytes();
    stack_offset = Utils::RoundUp(stack_offset, compiler::target::kWordSize);
  }
 
  // And finally put the arguments on the stack that are passed by pointer.
  for (int i = 0; i < num_args(); i++) {
    if (arg_index == i) {
      return stack_offset;
    }
    const auto& arg_location = Location(i);
    if (arg_location.IsPointerToMemory()) {
      stack_offset += arg_location.payload_type().SizeInBytes();
      stack_offset = Utils::RoundUp(stack_offset, compiler::target::kWordSize);
    }
  }
 
  // The total stack space we need.
  ASSERT(arg_index == kAfterLastArgumentIndex);
  return stack_offset;
}

◆ RepInFfiCall()

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

virtual

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

Definition at line 480 of file marshaller.cc.

                                                                           {
  intptr_t arg_index = ArgumentIndex(def_index_global);
  if (IsHandleCType(arg_index)) {
    // For FfiCall arguments, the FfiCall instruction takes a tagged pointer
    // from the IL. (It then creates a handle on the stack and passes a
    // pointer to the newly allocated handle to C.)
    //
    // For FfiCall returns, FfiCall returns the untagged pointer to the handle
    // to the IL, which then extracts the ptr field of the handle to retrieve
    // the tagged pointer.
    return ArgumentIndexIsReturn(arg_index) ? kUntagged : kTagged;
  }
  if (ArgumentIndexIsReturn(arg_index) && ReturnsCompound()) {
    // The IL creates a TypedData object which is stored on the stack, and the
    // FfiCall copies the compound value, however it is returned into that
    // TypedData object. In order to make the return value of the definition
    // defined, the same TypedData object is returned from the FfiCall.
    return kTagged;
  }
  const auto& location = Location(arg_index);
  if (location.IsPointerToMemory() || IsCompoundPointer(arg_index) ||
      IsTypedDataPointer(arg_index)) {
    // For arguments, the compound data being passed as a pointer is first
    // collected into a TypedData object by the IL, and that object is what is
    // passed to the FfiCall instruction. (The machine code generated by
    // FfiCall handles copying the data into non-GC-moveable memory and
    // passing a pointer to that memory to the C code.)
    const intptr_t def_index_in_arg =
        def_index_global - FirstDefinitionIndex(arg_index);
    if (def_index_in_arg == kTypedDataBaseIndex) {
      // The TypedDataBase object is managed by the GC, so the payload address
      // cannot be eagerly extracted in the IL, as that would create an
      // unsafe untagged address as an input to a GC-triggering instruction.
      return kTagged;
    } else {
      ASSERT_EQUAL(def_index_in_arg, kOffsetInBytesIndex);
      ASSERT(!IsTypedDataPointer(arg_index));
      return kUnboxedUword;
    }
  }
  return BaseMarshaller::RepInFfiCall(def_index_global);
}

◆ RequiredStackSpaceInBytes()

intptr_t dart::compiler::ffi::CallMarshaller::RequiredStackSpaceInBytes ( ) const

Definition at line 741 of file marshaller.cc.

                                                         {
  return PassByPointerStackOffset(kAfterLastArgumentIndex);
}

◆ ReturnsCompound()

bool dart::compiler::ffi::CallMarshaller::ReturnsCompound ( ) const

Definition at line 680 of file marshaller.cc.

                                           {
  return IsCompoundCType(compiler::ffi::kResultIndex);
}

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

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CallMarshaller()

◆ ~CallMarshaller()

Member Function Documentation

◆ CompoundReturnSizeInBytes()

◆ FromFunction()

◆ LocInFfiCall()

◆ NumDefinitions()

◆ NumReturnDefinitions()

◆ PassByPointerStackOffset()

◆ RepInFfiCall()

◆ RequiredStackSpaceInBytes()

◆ ReturnsCompound()