#include <il.h>

Inheritance diagram for dart::FfiCallInstr:

Public Member Functions
	FfiCallInstr (intptr_t deopt_id, const compiler::ffi::CallMarshaller &marshaller, bool is_leaf, InputsArray &&inputs)

intptr_t	TargetAddressIndex () const

intptr_t	CompoundReturnTypedDataIndex () const

virtual bool	MayThrow () const

virtual bool	MayCreateUnsafeUntaggedPointer () const

virtual bool	ComputeCanDeoptimize () const

virtual bool	ComputeCanDeoptimizeAfterCall () const

virtual bool	HasUnknownSideEffects () const

virtual bool	CanCallDart () const

virtual Representation	RequiredInputRepresentation (intptr_t idx) const

virtual Representation	representation () const

DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(FfiCallInstr, VariadicDefinition, FIELD_LIST) private void	EmitParamMoves (FlowGraphCompiler *compiler, const Register saved_fp, const Register temp0, const Register temp1)

void	EmitReturnMoves (FlowGraphCompiler *compiler, const Register temp0, const Register temp1)

	DISALLOW_COPY_AND_ASSIGN (FfiCallInstr)

Public Member Functions inherited from dart::VariadicDefinition
	VariadicDefinition (InputsArray &&inputs, intptr_t deopt_id=DeoptId::kNone)

	VariadicDefinition (InputsArray &&inputs, const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

	VariadicDefinition (const intptr_t num_inputs, intptr_t deopt_id=DeoptId::kNone)

intptr_t	InputCount () const

Value *	InputAt (intptr_t i) const

Public Member Functions inherited from dart::Definition
	Definition (intptr_t deopt_id=DeoptId::kNone)

	Definition (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

virtual intptr_t	CallCount () const

intptr_t	temp_index () const

void	set_temp_index (intptr_t index)

void	ClearTempIndex ()

bool	HasTemp () const

intptr_t	ssa_temp_index () const

void	set_ssa_temp_index (intptr_t index)

bool	HasSSATemp () const

void	ClearSSATempIndex ()

intptr_t	vreg (intptr_t index) const

intptr_t	location_count () const

bool	HasPairRepresentation () const

CompileType *	Type ()

bool	HasType () const

bool	IsInt64Definition ()

bool	IsInt32Definition ()

virtual CompileType	ComputeType () const

virtual bool	RecomputeType ()

PRINT_OPERANDS_TO_SUPPORT PRINT_TO_SUPPORT bool	UpdateType (CompileType new_type)

bool	HasUses () const

bool	HasOnlyUse (Value *use) const

bool	HasOnlyInputUse (Value *use) const

Value *	input_use_list () const

void	set_input_use_list (Value *head)

Value *	env_use_list () const

void	set_env_use_list (Value *head)

ValueListIterable	input_uses () const

void	AddInputUse (Value *value)

void	AddEnvUse (Value *value)

virtual bool	MayCreateUnsafeUntaggedPointer () const

virtual bool	CanReplaceWithConstant () const

virtual bool	CanEliminate (const BlockEntryInstr *block) const

void	ReplaceUsesWith (Definition *other)

void	ReplaceWithResult (Instruction replacement, Definition replacement_for_uses, ForwardInstructionIterator *iterator)

void	ReplaceWith (Definition other, ForwardInstructionIterator iterator)

Object &	constant_value ()

virtual void	InferRange (RangeAnalysis analysis, Range range)

Range *	range () const

void	set_range (const Range &)

virtual Definition *	Canonicalize (FlowGraph *flow_graph)

Definition *	Replacement ()

void	SetReplacement (Definition *other)

virtual AliasIdentity	Identity () const

virtual void	SetIdentity (AliasIdentity identity)

Definition *	OriginalDefinition ()

virtual Value *	RedefinedValue () const

Definition *	OriginalDefinitionIgnoreBoxingAndConstraints ()

virtual Definition *	AsDefinition ()

virtual const Definition *	AsDefinition () const

Public Member Functions inherited from dart::Instruction
	Instruction (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

	Instruction (intptr_t deopt_id=DeoptId::kNone)

virtual	~Instruction ()

virtual Tag	tag () const =0

virtual intptr_t	statistics_tag () const

intptr_t	deopt_id () const

virtual TokenPosition	token_pos () const

InstructionSource	source () const

virtual intptr_t	InputCount () const =0

virtual Value *	InputAt (intptr_t i) const =0

void	SetInputAt (intptr_t i, Value *value)

InputsIterable	inputs ()

void	UnuseAllInputs ()

virtual intptr_t	ArgumentCount () const

Value *	ArgumentValueAt (intptr_t index) const

Definition *	ArgumentAt (intptr_t index) const

virtual void	SetMoveArguments (MoveArgumentsArray *move_arguments)

virtual MoveArgumentsArray *	GetMoveArguments () const

virtual void	ReplaceInputsWithMoveArguments (MoveArgumentsArray *move_arguments)

bool	HasMoveArguments () const

void	RepairArgumentUsesInEnvironment () const

virtual bool	ComputeCanDeoptimize () const =0

virtual bool	ComputeCanDeoptimizeAfterCall () const

bool	CanDeoptimize () const

virtual void	Accept (InstructionVisitor *visitor)=0

Instruction *	previous () const

void	set_previous (Instruction *instr)

Instruction *	next () const

void	set_next (Instruction *instr)

void	LinkTo (Instruction *next)

Instruction *	RemoveFromGraph (bool return_previous=true)

virtual intptr_t	SuccessorCount () const

virtual BlockEntryInstr *	SuccessorAt (intptr_t index) const

SuccessorsIterable	successors () const

void	Goto (JoinEntryInstr *entry)

virtual const char *	DebugName () const =0

void	CheckField (const Field &field) const

const char *	ToCString () const

	DECLARE_INSTRUCTION_TYPE_CHECK (BlockEntryWithInitialDefs, BlockEntryWithInitialDefs) template< typename T > T *Cast()

template<typename T >
const T *	Cast () const

LocationSummary *	locs ()

bool	HasLocs () const

virtual LocationSummary *	MakeLocationSummary (Zone *zone, bool is_optimizing) const =0

void	InitializeLocationSummary (Zone *zone, bool optimizing)

virtual void	EmitNativeCode (FlowGraphCompiler *compiler)

Environment *	env () const

void	SetEnvironment (Environment *deopt_env)

void	RemoveEnvironment ()

void	ReplaceInEnvironment (Definition current, Definition replacement)

virtual intptr_t	NumberOfInputsConsumedBeforeCall () const

intptr_t	GetPassSpecificId (CompilerPass::Id pass) const

void	SetPassSpecificId (CompilerPass::Id pass, intptr_t id)

bool	HasPassSpecificId (CompilerPass::Id pass) const

bool	HasUnmatchedInputRepresentations () const

virtual Representation	RequiredInputRepresentation (intptr_t idx) const

SpeculativeMode	SpeculativeModeOfInputs () const

virtual SpeculativeMode	SpeculativeModeOfInput (intptr_t index) const

virtual Representation	representation () const

bool	WasEliminated () const

virtual intptr_t	DeoptimizationTarget () const

virtual Instruction *	Canonicalize (FlowGraph *flow_graph)

void	InsertBefore (Instruction *next)

void	InsertAfter (Instruction *prev)

Instruction *	AppendInstruction (Instruction *tail)

virtual bool	AllowsCSE () const

virtual bool	HasUnknownSideEffects () const =0

virtual bool	CanCallDart () const

virtual bool	CanTriggerGC () const

virtual BlockEntryInstr *	GetBlock ()

virtual intptr_t	inlining_id () const

virtual void	set_inlining_id (intptr_t value)

virtual bool	has_inlining_id () const

virtual uword	Hash () const

bool	Equals (const Instruction &other) const

virtual bool	AttributesEqual (const Instruction &other) const

void	InheritDeoptTarget (Zone zone, Instruction other)

bool	NeedsEnvironment () const

virtual bool	CanBecomeDeoptimizationTarget () const

void	InheritDeoptTargetAfter (FlowGraph flow_graph, Definition call, Definition *result)

virtual bool	MayThrow () const =0

virtual bool	MayHaveVisibleEffect () const

virtual bool	CanEliminate (const BlockEntryInstr *block) const

bool	CanEliminate ()

bool	IsDominatedBy (Instruction *dom)

void	ClearEnv ()

void	Unsupported (FlowGraphCompiler *compiler)

virtual bool	UseSharedSlowPathStub (bool is_optimizing) const

Location::Kind	RegisterKindForResult () 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 bool	CanExecuteGeneratedCodeInSafepoint ()

static intptr_t	InputCountForMarshaller (const compiler::ffi::CallMarshaller &marshaller)

Static Public Member Functions inherited from dart::Definition
static bool	IsArrayLength (Definition *def)

Static Public Member Functions inherited from dart::Instruction
static const ICData *	GetICData (const ZoneGrowableArray< const ICData * > &ic_data_array, intptr_t deopt_id, bool is_static_call)

static LocationSummary *	MakeCallSummary (Zone zone, const Instruction instr, LocationSummary *locs=nullptr)

static bool	SlowPathSharingSupported (bool is_optimizing)

Additional Inherited Members
Public Types inherited from dart::Instruction
enum	Tag { FOR_EACH_INSTRUCTION =(DECLARE_TAG) kNumInstructions }

enum	SpeculativeMode { kGuardInputs , kNotSpeculative }

using	InputsIterable = InstructionIndexedPropertyIterable< InputsTrait >

using	SuccessorsIterable = InstructionIndexedPropertyIterable< SuccessorsTrait >

Static Public Attributes inherited from dart::Definition
static constexpr intptr_t	kReplacementMarker = -2

Static Public Attributes inherited from dart::Instruction
static const intptr_t	kInstructionAttrs [kNumInstructions]

Protected Member Functions inherited from dart::Definition
void	set_type (CompileType *type)

Protected Member Functions inherited from dart::Instruction
intptr_t	GetDeoptId () const

virtual void	CopyDeoptIdFrom (const Instruction &instr)

void	WriteExtraWithoutInputs (FlowGraphSerializer *s)

void	ReadExtraWithoutInputs (FlowGraphDeserializer *d)

Protected Attributes inherited from dart::VariadicDefinition
InputsArray	inputs_

Protected Attributes inherited from dart::Definition
Range *	range_ = nullptr

Detailed Description

Definition at line 6078 of file il.h.

Constructor & Destructor Documentation

◆ FfiCallInstr()

dart::FfiCallInstr::FfiCallInstr	(	intptr_t	deopt_id,
		const compiler::ffi::CallMarshaller &	marshaller,
		bool	is_leaf,
		InputsArray &&	inputs
	)

inline

Definition at line 6080 of file il.h.

      : VariadicDefinition(std::move(inputs), deopt_id),
        marshaller_(marshaller),
        is_leaf_(is_leaf) {
#if defined(DEBUG)
    ASSERT_EQUAL(InputCount(), InputCountForMarshaller(marshaller));
    // No argument to an FfiCall should be an unsafe untagged pointer,
    // including the target address.
    for (intptr_t i = 0; i < InputCount(); i++) {
      ASSERT(!InputAt(i)->definition()->MayCreateUnsafeUntaggedPointer());
    }
#endif
  }

Member Function Documentation

◆ CanCallDart()

virtual bool dart::FfiCallInstr::CanCallDart ( ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 6132 of file il.h.

6132{ return false; }

◆ CanExecuteGeneratedCodeInSafepoint()

static bool dart::FfiCallInstr::CanExecuteGeneratedCodeInSafepoint ( )

inlinestatic

Definition at line 6142 of file il.h.

                                                   {
    return FLAG_precompiled_mode;
  }

◆ CompoundReturnTypedDataIndex()

intptr_t dart::FfiCallInstr::CompoundReturnTypedDataIndex ( ) const

inline

Definition at line 6105 of file il.h.

                                                {
    ASSERT(marshaller_.ReturnsCompound());
    return marshaller_.NumArgumentDefinitions() + 1;
  }

◆ ComputeCanDeoptimize()

virtual bool dart::FfiCallInstr::ComputeCanDeoptimize ( ) const

inlinevirtual

Implements dart::Instruction.

Definition at line 6124 of file il.h.

6124{ return false; }

◆ ComputeCanDeoptimizeAfterCall()

virtual bool dart::FfiCallInstr::ComputeCanDeoptimizeAfterCall ( ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 6125 of file il.h.

                                                     {
    return !CompilerState::Current().is_aot();
  }

◆ DISALLOW_COPY_AND_ASSIGN()

dart::FfiCallInstr::DISALLOW_COPY_AND_ASSIGN ( FfiCallInstr )

◆ EmitParamMoves()

void dart::FfiCallInstr::EmitParamMoves	(	FlowGraphCompiler *	compiler,
		const Register	saved_fp,
		const Register	temp0,
		const Register	temp1
	)

Definition at line 7478 of file il.cc.

                                                        {
  __ Comment("EmitParamMoves");
 
  // Moves for return pointer.
  const auto& return_location =
      marshaller_.Location(compiler::ffi::kResultIndex);
  if (return_location.IsPointerToMemory()) {
    __ Comment("return_location.IsPointerToMemory");
    const auto& pointer_location =
        return_location.AsPointerToMemory().pointer_location();
    const auto& pointer_register =
        pointer_location.IsRegisters()
            ? pointer_location.AsRegisters().reg_at(0)
            : temp0;
    __ MoveRegister(pointer_register, SPREG);
    __ AddImmediate(pointer_register, marshaller_.PassByPointerStackOffset(
                                          compiler::ffi::kResultIndex));
 
    if (pointer_location.IsStack()) {
      const auto& pointer_stack = pointer_location.AsStack();
      __ StoreMemoryValue(pointer_register, pointer_stack.base_register(),
                          pointer_stack.offset_in_bytes());
    }
  }
 
  // Moves for arguments.
  compiler::ffi::FrameRebase rebase(compiler->zone(), /*old_base=*/FPREG,
                                    /*new_base=*/saved_fp,
                                    /*stack_delta=*/0);
  intptr_t def_index = 0;
  for (intptr_t arg_index = 0; arg_index < marshaller_.num_args();
       arg_index++) {
    const intptr_t num_defs = marshaller_.NumDefinitions(arg_index);
    const auto& arg_target = marshaller_.Location(arg_index);
    __ Comment("arg_index %" Pd " arg_target %s", arg_index,
               arg_target.ToCString());
 
    // First deal with moving all individual definitions passed in to the
    // FfiCall to the right native location based on calling convention.
    for (intptr_t i = 0; i < num_defs; i++) {
      if ((arg_target.IsPointerToMemory() ||
           marshaller_.IsCompoundPointer(arg_index)) &&
          i == 1) {
        // The offset_in_bytes is not an argument for C, so don't move it.
        // It is used as offset_in_bytes_loc below and moved there if
        // necessary.
        def_index++;
        continue;
      }
      __ Comment("  def_index %" Pd, def_index);
      Location origin = rebase.Rebase(locs()->in(def_index));
      const Representation origin_rep = RequiredInputRepresentation(def_index);
 
      // Find the native location where this individual definition should be
      // moved to.
      const auto& def_target =
          arg_target.payload_type().IsPrimitive() ? arg_target
          : arg_target.IsMultiple() ? *arg_target.AsMultiple().locations()[i]
          : arg_target.IsPointerToMemory()
              ? arg_target.AsPointerToMemory().pointer_location()
              : /*arg_target.IsStack()*/ arg_target.Split(compiler->zone(),
                                                          num_defs, i);
 
      ConstantTemporaryAllocator temp_alloc(temp0);
      if (origin.IsConstant()) {
        __ Comment("origin.IsConstant()");
        ASSERT(!marshaller_.IsHandleCType(arg_index));
        ASSERT(!marshaller_.IsTypedDataPointer(arg_index));
        ASSERT(!marshaller_.IsCompoundPointer(arg_index));
        compiler->EmitMoveConst(def_target, origin, origin_rep, &temp_alloc);
      } else if (origin.IsPairLocation() &&
                 (origin.AsPairLocation()->At(0).IsConstant() ||
                  origin.AsPairLocation()->At(1).IsConstant())) {
        // Note: half of the pair can be constant.
        __ Comment("origin.IsPairLocation() and constant");
        ASSERT(!marshaller_.IsHandleCType(arg_index));
        ASSERT(!marshaller_.IsTypedDataPointer(arg_index));
        ASSERT(!marshaller_.IsCompoundPointer(arg_index));
        compiler->EmitMoveConst(def_target, origin, origin_rep, &temp_alloc);
      } else if (marshaller_.IsHandleCType(arg_index)) {
        __ Comment("marshaller_.IsHandleCType(arg_index)");
        // Handles are passed into FfiCalls as Tagged values on the stack, and
        // then we pass pointers to these handles to the native function here.
        ASSERT(origin_rep == kTagged);
        ASSERT(compiler::target::LocalHandle::ptr_offset() == 0);
        ASSERT(compiler::target::LocalHandle::InstanceSize() ==
               compiler::target::kWordSize);
        ASSERT(num_defs == 1);
        ASSERT(origin.IsStackSlot());
        if (def_target.IsRegisters()) {
          __ AddImmediate(def_target.AsLocation().reg(), origin.base_reg(),
                          origin.stack_index() * compiler::target::kWordSize);
        } else {
          ASSERT(def_target.IsStack());
          const auto& target_stack = def_target.AsStack();
          __ AddImmediate(temp0, origin.base_reg(),
                          origin.stack_index() * compiler::target::kWordSize);
          __ StoreToOffset(temp0, target_stack.base_register(),
                           target_stack.offset_in_bytes());
        }
      } else {
        __ Comment("def_target %s <- origin %s %s",
                   def_target.ToCString(compiler->zone()), origin.ToCString(),
                   RepresentationUtils::ToCString(origin_rep));
#ifdef DEBUG
        // Stack arguments split are in word-size chunks. These chunks can copy
        // too much. However, that doesn't matter in practise because we process
        // the stack in order.
        // It only matters for the last chunk, it should not overwrite what was
        // already on the stack.
        if (def_target.IsStack()) {
          const auto& def_target_stack = def_target.AsStack();
          ASSERT(def_target_stack.offset_in_bytes() +
                     def_target.payload_type().SizeInBytes() <=
                 marshaller_.RequiredStackSpaceInBytes());
        }
#endif
        if (marshaller_.IsTypedDataPointer(arg_index) ||
            marshaller_.IsCompoundPointer(arg_index)) {
          // Unwrap typed data before move to native location.
          __ Comment("Load typed data base address");
          if (origin.IsStackSlot()) {
            compiler->EmitMove(Location::RegisterLocation(temp0), origin,
                               &temp_alloc);
            origin = Location::RegisterLocation(temp0);
          }
          ASSERT(origin.IsRegister());
          __ LoadFromSlot(origin.reg(), origin.reg(), Slot::PointerBase_data());
          if (marshaller_.IsCompoundPointer(arg_index)) {
            __ Comment("Load offset in bytes");
            const intptr_t offset_in_bytes_def_index = def_index + 1;
            const Location offset_in_bytes_loc =
                rebase.Rebase(locs()->in(offset_in_bytes_def_index));
            Register offset_in_bytes_reg = kNoRegister;
            if (offset_in_bytes_loc.IsRegister()) {
              offset_in_bytes_reg = offset_in_bytes_loc.reg();
            } else {
              offset_in_bytes_reg = temp1;
              NoTemporaryAllocator no_temp;
              compiler->EmitMove(
                  Location::RegisterLocation(offset_in_bytes_reg),
                  offset_in_bytes_loc, &no_temp);
            }
            __ AddRegisters(origin.reg(), offset_in_bytes_reg);
          }
        }
        compiler->EmitMoveToNative(def_target, origin, origin_rep, &temp_alloc);
      }
      def_index++;
    }
 
    // Then make sure that any pointers passed through the calling convention
    // actually have a copy of the struct.
    // Note that the step above has already moved the pointer into the expected
    // native location.
    if (arg_target.IsPointerToMemory()) {
      __ Comment("arg_target.IsPointerToMemory");
      NoTemporaryAllocator temp_alloc;
      const auto& pointer_loc =
          arg_target.AsPointerToMemory().pointer_location();
 
      // TypedData data pointed to in temp.
      const auto& dst = compiler::ffi::NativeRegistersLocation(
          compiler->zone(), pointer_loc.payload_type(),
          pointer_loc.container_type(), temp0);
      compiler->EmitNativeMove(dst, pointer_loc, &temp_alloc);
      __ LoadFromSlot(temp0, temp0, Slot::PointerBase_data());
 
      __ Comment("IsPointerToMemory add offset");
      const intptr_t offset_in_bytes_def_index =
          def_index - 1;  // ++'d already.
      const Location offset_in_bytes_loc =
          rebase.Rebase(locs()->in(offset_in_bytes_def_index));
      Register offset_in_bytes_reg = kNoRegister;
      if (offset_in_bytes_loc.IsRegister()) {
        offset_in_bytes_reg = offset_in_bytes_loc.reg();
      } else {
        offset_in_bytes_reg = temp1;
        NoTemporaryAllocator no_temp;
        compiler->EmitMove(Location::RegisterLocation(offset_in_bytes_reg),
                           offset_in_bytes_loc, &no_temp);
      }
      __ AddRegisters(temp0, offset_in_bytes_reg);
 
      // Copy chunks. The destination may be rounded up to a multiple of the
      // word size, because we do the same rounding when we allocate the space
      // on the stack. But source may not be allocated by the VM and end at a
      // page boundary.
      __ Comment("IsPointerToMemory copy chunks");
      const intptr_t sp_offset =
          marshaller_.PassByPointerStackOffset(arg_index);
      __ UnrolledMemCopy(SPREG, sp_offset, temp0, 0,
                         arg_target.payload_type().SizeInBytes(), temp1);
 
      // Store the stack address in the argument location.
      __ MoveRegister(temp0, SPREG);
      __ AddImmediate(temp0, sp_offset);
      const auto& src = compiler::ffi::NativeRegistersLocation(
          compiler->zone(), pointer_loc.payload_type(),
          pointer_loc.container_type(), temp0);
      __ Comment("pointer_loc %s <- src %s", pointer_loc.ToCString(),
                 src.ToCString());
      compiler->EmitNativeMove(pointer_loc, src, &temp_alloc);
    }
  }
 
  __ Comment("EmitParamMovesEnd");
}

◆ EmitReturnMoves()

void dart::FfiCallInstr::EmitReturnMoves	(	FlowGraphCompiler *	compiler,
		const Register	temp0,
		const Register	temp1
	)

Definition at line 7690 of file il.cc.

                                                         {
  const auto& returnLocation =
      marshaller_.Location(compiler::ffi::kResultIndex);
  if (returnLocation.payload_type().IsVoid()) {
    return;
  }
 
  __ Comment("EmitReturnMoves");
 
  NoTemporaryAllocator no_temp;
  if (returnLocation.IsRegisters() || returnLocation.IsFpuRegisters()) {
    const auto& src = returnLocation;
    const Location dst_loc = locs()->out(0);
    const Representation dst_type = representation();
    compiler->EmitMoveFromNative(dst_loc, dst_type, src, &no_temp);
  } else if (marshaller_.ReturnsCompound()) {
    ASSERT(returnLocation.payload_type().IsCompound());
 
    // Get the typed data pointer which we have pinned to a stack slot.
    const Location typed_data_loc = locs()->in(CompoundReturnTypedDataIndex());
    if (typed_data_loc.IsStackSlot()) {
      ASSERT(typed_data_loc.base_reg() == FPREG);
      // If this is a leaf call there is no extra call frame to step through.
      if (is_leaf_) {
        __ LoadMemoryValue(temp0, FPREG, typed_data_loc.ToStackSlotOffset());
      } else {
        __ LoadMemoryValue(
            temp0, FPREG,
            kSavedCallerFpSlotFromFp * compiler::target::kWordSize);
        __ LoadMemoryValue(temp0, temp0, typed_data_loc.ToStackSlotOffset());
      }
    } else {
      compiler->EmitMove(Location::RegisterLocation(temp0), typed_data_loc,
                         &no_temp);
    }
    __ LoadFromSlot(temp0, temp0, Slot::PointerBase_data());
 
    if (returnLocation.IsPointerToMemory()) {
      // Copy blocks from the stack location to TypedData.
      // Struct size is rounded up to a multiple of target::kWordSize.
      // This is safe because we do the same rounding when we allocate the
      // TypedData in IL.
      const intptr_t sp_offset =
          marshaller_.PassByPointerStackOffset(compiler::ffi::kResultIndex);
      __ UnrolledMemCopy(temp0, 0, SPREG, sp_offset,
                         marshaller_.CompoundReturnSizeInBytes(), temp1);
    } else {
      ASSERT(returnLocation.IsMultiple());
      // Copy to the struct from the native locations.
      const auto& multiple =
          marshaller_.Location(compiler::ffi::kResultIndex).AsMultiple();
 
      int offset_in_bytes = 0;
      for (int i = 0; i < multiple.locations().length(); i++) {
        const auto& src = *multiple.locations().At(i);
        const auto& dst = compiler::ffi::NativeStackLocation(
            src.payload_type(), src.container_type(), temp0, offset_in_bytes);
        compiler->EmitNativeMove(dst, src, &no_temp);
        offset_in_bytes += src.payload_type().SizeInBytes();
      }
    }
  } else {
    UNREACHABLE();
  }
 
  __ Comment("EmitReturnMovesEnd");
}

◆ HasUnknownSideEffects()

virtual bool dart::FfiCallInstr::HasUnknownSideEffects ( ) const

inlinevirtual

Implements dart::Instruction.

Definition at line 6129 of file il.h.

6129{ return true; }

◆ InputCountForMarshaller()

static intptr_t dart::FfiCallInstr::InputCountForMarshaller ( const compiler::ffi::CallMarshaller & marshaller )

inlinestatic

Definition at line 6146 of file il.h.

                                                   {
    return marshaller.NumArgumentDefinitions() + 1 +
           (marshaller.ReturnsCompound() ? 1 : 0);
  }

◆ MayCreateUnsafeUntaggedPointer()

virtual bool dart::FfiCallInstr::MayCreateUnsafeUntaggedPointer ( ) const

inlinevirtual

Reimplemented from dart::Definition.

Definition at line 6115 of file il.h.

                                                      {
    // The only case where we have an untagged result is when the return
    // value is a pointer, which is then stored in a newly allocated FFI
    // Pointer object by the generated IL, so the C code must return an
    // external (not GC-movable) address to Dart.
    return false;
  }

◆ MayThrow()

virtual bool dart::FfiCallInstr::MayThrow ( ) const

inlinevirtual

Implements dart::Instruction.

Definition at line 6110 of file il.h.

                                {
    // By Dart_PropagateError.
    return true;
  }

◆ representation()

Representation dart::FfiCallInstr::representation ( ) const

virtual

Reimplemented from dart::Instruction.

Definition at line 8095 of file il.cc.

                                                  {
  if (marshaller_.ReturnsCompound()) {
    // Don't care, we're discarding the value.
    return kTagged;
  }
  if (marshaller_.IsHandleCType(compiler::ffi::kResultIndex)) {
    // The call returns a Dart_Handle, from which we need to extract the
    // tagged pointer using LoadField with an appropriate slot.
    return kUntagged;
  }
  return marshaller_.RepInFfiCall(compiler::ffi::kResultIndex);
}

◆ RequiredInputRepresentation()

Representation dart::FfiCallInstr::RequiredInputRepresentation ( intptr_t idx ) const

virtual

Reimplemented from dart::Instruction.

Definition at line 7408 of file il.cc.

                                                                           {
  if (idx < TargetAddressIndex()) {
    // All input handles are passed as tagged values to FfiCallInstr and
    // are given stack locations. FfiCallInstr then passes an untagged pointer
    // to the handle on the stack (Dart_Handle) to the C function.
    if (marshaller_.IsHandleCType(marshaller_.ArgumentIndex(idx))) {
      return kTagged;
    }
    return marshaller_.RepInFfiCall(idx);
  } else if (idx == TargetAddressIndex()) {
#if defined(DEBUG)
    auto const rep =
        InputAt(TargetAddressIndex())->definition()->representation();
    ASSERT(rep == kUntagged || rep == kUnboxedAddress);
#endif
    return kNoRepresentation;  // Allows kUntagged or kUnboxedAddress.
  } else {
    ASSERT(idx == CompoundReturnTypedDataIndex());
    return kTagged;
  }
}

◆ TargetAddressIndex()

intptr_t dart::FfiCallInstr::TargetAddressIndex ( ) const

inline

Definition at line 6100 of file il.h.

                                      {
    return marshaller_.NumArgumentDefinitions();
  }

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

third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.h
third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.cc

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FfiCallInstr()

Member Function Documentation

◆ CanCallDart()

◆ CanExecuteGeneratedCodeInSafepoint()

◆ CompoundReturnTypedDataIndex()

◆ ComputeCanDeoptimize()

◆ ComputeCanDeoptimizeAfterCall()

◆ DISALLOW_COPY_AND_ASSIGN()

◆ EmitParamMoves()

◆ EmitReturnMoves()

◆ HasUnknownSideEffects()

◆ InputCountForMarshaller()

◆ MayCreateUnsafeUntaggedPointer()

◆ MayThrow()

◆ representation()

◆ RequiredInputRepresentation()

◆ TargetAddressIndex()