#include <il.h>

Inheritance diagram for dart::MemoryCopyInstr:

Public Types
enum	{ kSrcPos = 0 , kDestPos = 1 , kSrcStartPos = 2 , kDestStartPos = 3 , kLengthPos = 4 }

Public Types inherited from dart::TemplateInstruction< 5, NoThrow >
using	BaseClass = typename NoCSE< Instruction, PureInstruction >::Base

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 >

Public Member Functions
	MemoryCopyInstr (Value src, classid_t src_cid, Value dest, classid_t dest_cid, Value src_start, Value dest_start, Value *length, bool unboxed_inputs, bool can_overlap=true)

virtual Representation	RequiredInputRepresentation (intptr_t index) const

virtual bool	ComputeCanDeoptimize () const

virtual bool	HasUnknownSideEffects () const

virtual bool	AttributesEqual (const Instruction &other) const

Value *	src () const

Value *	dest () const

Value *	src_start () const

Value *	dest_start () const

Value *	length () const

classid_t	src_cid () const

classid_t	dest_cid () const

intptr_t	element_size () const

bool	unboxed_inputs () const

bool	can_overlap () const

virtual Instruction *	Canonicalize (FlowGraph *flow_graph)

PRINT_OPERANDS_TO_SUPPORT	DECLARE_ATTRIBUTE (element_size())

DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MemoryCopyInstr, TemplateInstruction, FIELD_LIST) private void	EmitUnrolledCopy (FlowGraphCompiler *compiler, Register dest_reg, Register src_reg, intptr_t num_elements, bool reversed)

void	PrepareLengthRegForLoop (FlowGraphCompiler compiler, Register length_reg, compiler::Label done)

void	EmitLoopCopy (FlowGraphCompiler compiler, Register dest_reg, Register src_reg, Register length_reg, compiler::Label done, compiler::Label *copy_forwards=nullptr)

	DISALLOW_COPY_AND_ASSIGN (MemoryCopyInstr)

Public Member Functions inherited from dart::TemplateInstruction< 5, NoThrow >
	TemplateInstruction (intptr_t deopt_id=DeoptId::kNone)

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

virtual intptr_t	InputCount () const

virtual Value *	InputAt (intptr_t i) const

virtual bool	MayThrow () 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	IsArrayTypeSupported (classid_t array_cid)

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
Static Public Attributes inherited from dart::Instruction
static const intptr_t	kInstructionAttrs [kNumInstructions]

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::TemplateInstruction< 5, NoThrow >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 3146 of file il.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kSrcPos
kDestPos
kSrcStartPos
kDestStartPos
kLengthPos

Definition at line 3173 of file il.h.

       {
    kSrcPos = 0,
    kDestPos = 1,
    kSrcStartPos = 2,
    kDestStartPos = 3,
    kLengthPos = 4
  };

Constructor & Destructor Documentation

◆ MemoryCopyInstr()

dart::MemoryCopyInstr::MemoryCopyInstr	(	Value *	src,
		classid_t	src_cid,
		Value *	dest,
		classid_t	dest_cid,
		Value *	src_start,
		Value *	dest_start,
		Value *	length,
		bool	unboxed_inputs,
		bool	can_overlap = `true`
	)

inline

Definition at line 3148 of file il.h.

      : src_cid_(src_cid),
        dest_cid_(dest_cid),
        element_size_(Instance::ElementSizeFor(src_cid)),
        unboxed_inputs_(unboxed_inputs),
        can_overlap_(can_overlap) {
    ASSERT(IsArrayTypeSupported(src_cid));
    ASSERT(IsArrayTypeSupported(dest_cid));
    ASSERT_EQUAL(Instance::ElementSizeFor(src_cid),
                 Instance::ElementSizeFor(dest_cid));
    SetInputAt(kSrcPos, src);
    SetInputAt(kDestPos, dest);
    SetInputAt(kSrcStartPos, src_start);
    SetInputAt(kDestStartPos, dest_start);
    SetInputAt(kLengthPos, length);
  }

Member Function Documentation

◆ AttributesEqual()

virtual bool dart::MemoryCopyInstr::AttributesEqual ( const Instruction & other ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 3195 of file il.h.

                                                               {
    if (auto* const copy = other.AsMemoryCopy()) {
      if (element_size_ != copy->element_size_) return false;
      if (unboxed_inputs_ != copy->unboxed_inputs_) return false;
      if (can_overlap_ != copy->can_overlap_) return false;
      if (src_cid_ != copy->src_cid_) return false;
      if (dest_cid_ != copy->dest_cid_) return false;
      return true;
    }
    return false;
  }

◆ can_overlap()

bool dart::MemoryCopyInstr::can_overlap ( ) const

inline

Definition at line 3217 of file il.h.

3217{ return can_overlap_; }

◆ Canonicalize()

Instruction * dart::MemoryCopyInstr::Canonicalize ( FlowGraph * flow_graph )

virtual

Reimplemented from dart::Instruction.

Definition at line 6954 of file il.cc.

                                                                {
  flow_graph->ExtractExternalUntaggedPayload(this, src(), src_cid_);
  flow_graph->ExtractExternalUntaggedPayload(this, dest(), dest_cid_);
 
  if (!length()->BindsToSmiConstant()) {
    return this;
  } else if (length()->BoundSmiConstant() == 0) {
    // Nothing to copy.
    return nullptr;
  }
 
  if (!src_start()->BindsToSmiConstant() ||
      !dest_start()->BindsToSmiConstant()) {
    // TODO(https://dartbug.com/51031): Consider adding support for src/dest
    // starts to be in bytes rather than element size.
    return this;
  }
 
  intptr_t new_length = length()->BoundSmiConstant();
  intptr_t new_src_start = src_start()->BoundSmiConstant();
  intptr_t new_dest_start = dest_start()->BoundSmiConstant();
  intptr_t new_element_size = element_size_;
  while (((new_length | new_src_start | new_dest_start) & 1) == 0 &&
         new_element_size < kMaxElementSizeForEfficientCopy) {
    new_length >>= 1;
    new_src_start >>= 1;
    new_dest_start >>= 1;
    new_element_size <<= 1;
  }
  if (new_element_size == element_size_) {
    return this;
  }
 
  // The new element size is larger than the original one, so it must be > 1.
  // That means unboxed integers will always require a shift, but Smis
  // may not if element_size == 2, so always use Smis.
  auto* const Z = flow_graph->zone();
  auto* const length_instr =
      flow_graph->GetConstant(Smi::ZoneHandle(Z, Smi::New(new_length)));
  auto* const src_start_instr =
      flow_graph->GetConstant(Smi::ZoneHandle(Z, Smi::New(new_src_start)));
  auto* const dest_start_instr =
      flow_graph->GetConstant(Smi::ZoneHandle(Z, Smi::New(new_dest_start)));
  length()->BindTo(length_instr);
  src_start()->BindTo(src_start_instr);
  dest_start()->BindTo(dest_start_instr);
  element_size_ = new_element_size;
  unboxed_inputs_ = false;
  return this;
}

◆ ComputeCanDeoptimize()

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

inlinevirtual

Implements dart::Instruction.

Definition at line 3192 of file il.h.

3192{ return false; }

◆ DECLARE_ATTRIBUTE()

PRINT_OPERANDS_TO_SUPPORT dart::MemoryCopyInstr::DECLARE_ATTRIBUTE ( element_size() )

◆ dest()

Value * dart::MemoryCopyInstr::dest ( ) const

inline

Definition at line 3208 of file il.h.

3208{ return inputs_[kDestPos]; }

dart::TemplateInstruction< 5, NoThrow >::inputs_

EmbeddedArray< Value *, N > inputs_

Definition: il.h:1522

◆ dest_cid()

classid_t dart::MemoryCopyInstr::dest_cid ( ) const

inline

Definition at line 3214 of file il.h.

3214{ return dest_cid_; }

◆ dest_start()

Value * dart::MemoryCopyInstr::dest_start ( ) const

inline

Definition at line 3210 of file il.h.

3210{ return inputs_[kDestStartPos]; }

◆ DISALLOW_COPY_AND_ASSIGN()

dart::MemoryCopyInstr::DISALLOW_COPY_AND_ASSIGN ( MemoryCopyInstr )

◆ element_size()

intptr_t dart::MemoryCopyInstr::element_size ( ) const

inline

Definition at line 3215 of file il.h.

3215{ return element_size_; }

◆ EmitLoopCopy()

void dart::MemoryCopyInstr::EmitLoopCopy	(	FlowGraphCompiler *	compiler,
		Register	dest_reg,
		Register	src_reg,
		Register	length_reg,
		compiler::Label *	done,
		compiler::Label *	copy_forwards = `nullptr`
	)

◆ EmitUnrolledCopy()

void dart::MemoryCopyInstr::EmitUnrolledCopy	(	FlowGraphCompiler *	compiler,
		Register	dest_reg,
		Register	src_reg,
		intptr_t	num_elements,
		bool	reversed
	)

Definition at line 7101 of file il.cc.

                                                      {
  ASSERT(element_size_ <= 16);
  const intptr_t num_bytes = num_elements * element_size_;
#if defined(TARGET_ARCH_ARM64)
  // We use LDP/STP with TMP/TMP2 to handle 16-byte moves.
  const intptr_t mov_size = element_size_;
#else
  const intptr_t mov_size =
      Utils::Minimum<intptr_t>(element_size_, compiler::target::kWordSize);
#endif
  const intptr_t mov_repeat = num_bytes / mov_size;
  ASSERT(num_bytes % mov_size == 0);
 
#if defined(TARGET_ARCH_IA32)
  // No TMP on IA32, so we have to allocate one instead.
  const Register temp_reg = locs()->temp(0).reg();
#else
  const Register temp_reg = TMP;
#endif
  for (intptr_t i = 0; i < mov_repeat; i++) {
    const intptr_t offset = (reversed ? (mov_repeat - (i + 1)) : i) * mov_size;
    switch (mov_size) {
      case 1:
        __ LoadFromOffset(temp_reg, src_reg, offset, compiler::kUnsignedByte);
        __ StoreToOffset(temp_reg, dest_reg, offset, compiler::kUnsignedByte);
        break;
      case 2:
        __ LoadFromOffset(temp_reg, src_reg, offset,
                          compiler::kUnsignedTwoBytes);
        __ StoreToOffset(temp_reg, dest_reg, offset,
                         compiler::kUnsignedTwoBytes);
        break;
      case 4:
        __ LoadFromOffset(temp_reg, src_reg, offset,
                          compiler::kUnsignedFourBytes);
        __ StoreToOffset(temp_reg, dest_reg, offset,
                         compiler::kUnsignedFourBytes);
        break;
      case 8:
#if defined(TARGET_ARCH_IS_64_BIT)
        __ LoadFromOffset(temp_reg, src_reg, offset, compiler::kEightBytes);
        __ StoreToOffset(temp_reg, dest_reg, offset, compiler::kEightBytes);
#else
        UNREACHABLE();
#endif
        break;
      case 16: {
#if defined(TARGET_ARCH_ARM64)
        __ ldp(
            TMP, TMP2,
            compiler::Address(src_reg, offset, compiler::Address::PairOffset));
        __ stp(
            TMP, TMP2,
            compiler::Address(dest_reg, offset, compiler::Address::PairOffset));
#else
        UNREACHABLE();
#endif
        break;
      }
      default:
        UNREACHABLE();
    }
  }
 
  if (FLAG_target_memory_sanitizer) {
#if defined(TARGET_ARCH_X64)
    RegisterSet kVolatileRegisterSet(CallingConventions::kVolatileCpuRegisters,
                                     CallingConventions::kVolatileXmmRegisters);
    __ PushRegisters(kVolatileRegisterSet);
    __ MsanUnpoison(dest_reg, num_bytes);
    __ PopRegisters(kVolatileRegisterSet);
#endif
  }
}

◆ HasUnknownSideEffects()

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

inlinevirtual

Implements dart::Instruction.

Definition at line 3193 of file il.h.

3193{ return true; }

◆ IsArrayTypeSupported()

static bool dart::MemoryCopyInstr::IsArrayTypeSupported ( classid_t array_cid )

inlinestatic

Definition at line 3283 of file il.h.

                                                        {
    // We don't handle clamping negative values in this instruction, instead
    // those are handled via a native call.
    if (IsClampedTypedDataBaseClassId(array_cid)) return false;
    // We don't support the following cids for the given reasons:
    // * kStringCid: doesn't give element size information or information
    //   about how the payload address is calculated.
    // * kPointerCid: doesn't give element size or signedness information.
    if (array_cid == kPointerCid || array_cid == kStringCid) return false;
    return IsTypedDataBaseClassId(array_cid) || IsStringClassId(array_cid);
  }

◆ length()

Value * dart::MemoryCopyInstr::length ( ) const

inline

Definition at line 3211 of file il.h.

3211{ return inputs_[kLengthPos]; }

◆ PrepareLengthRegForLoop()

void dart::MemoryCopyInstr::PrepareLengthRegForLoop	(	FlowGraphCompiler *	compiler,
		Register	length_reg,
		compiler::Label *	done
	)

◆ RequiredInputRepresentation()

virtual Representation dart::MemoryCopyInstr::RequiredInputRepresentation ( intptr_t index ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 3183 of file il.h.

                                                                           {
    if (index == kSrcPos || index == kDestPos) {
      // Can be either tagged or untagged.
      return kNoRepresentation;
    }
    ASSERT(index <= kLengthPos);
    return unboxed_inputs() ? kUnboxedIntPtr : kTagged;
  }

◆ src()

Value * dart::MemoryCopyInstr::src ( ) const

inline

Definition at line 3207 of file il.h.

3207{ return inputs_[kSrcPos]; }

◆ src_cid()

classid_t dart::MemoryCopyInstr::src_cid ( ) const

inline

Definition at line 3213 of file il.h.

3213{ return src_cid_; }

◆ src_start()

Value * dart::MemoryCopyInstr::src_start ( ) const

inline

Definition at line 3209 of file il.h.

3209{ return inputs_[kSrcStartPos]; }

◆ unboxed_inputs()

bool dart::MemoryCopyInstr::unboxed_inputs ( ) const

inline

Definition at line 3216 of file il.h.

3216{ return unboxed_inputs_; }

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 Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ MemoryCopyInstr()

Member Function Documentation

◆ AttributesEqual()

◆ can_overlap()

◆ Canonicalize()

◆ ComputeCanDeoptimize()

◆ DECLARE_ATTRIBUTE()

◆ dest()

◆ dest_cid()

◆ dest_start()

◆ DISALLOW_COPY_AND_ASSIGN()

◆ element_size()

◆ EmitLoopCopy()

◆ EmitUnrolledCopy()

◆ HasUnknownSideEffects()

◆ IsArrayTypeSupported()

◆ length()

◆ PrepareLengthRegForLoop()

◆ RequiredInputRepresentation()

◆ src()

◆ src_cid()

◆ src_start()

◆ unboxed_inputs()