#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 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

Static Public Member Functions
static bool	IsArrayTypeSupported (classid_t array_cid)

Additional Inherited Members
Protected Attributes inherited from dart::TemplateInstruction< 5, NoThrow >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 3128 of file il.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kSrcPos
kDestPos
kSrcStartPos
kDestStartPos
kLengthPos

Definition at line 3155 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 3130 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

Definition at line 3177 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 3199 of file il.h.

3199{ return can_overlap_; }

◆ Canonicalize()

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

virtual

Definition at line 6961 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

Definition at line 3174 of file il.h.

3174{ return false; }

◆ DECLARE_ATTRIBUTE()

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

◆ dest()

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

inline

Definition at line 3190 of file il.h.

3190{ return inputs_[kDestPos]; }

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

EmbeddedArray< Value *, N > inputs_

Definition il.h:1516

◆ dest_cid()

classid_t dart::MemoryCopyInstr::dest_cid ( ) const

inline

Definition at line 3196 of file il.h.

3196{ return dest_cid_; }

◆ dest_start()

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

inline

Definition at line 3192 of file il.h.

3192{ 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 3197 of file il.h.

3197{ 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 7110 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 defined(USING_MEMORY_SANITIZER) && 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

Definition at line 3175 of file il.h.

3175{ return true; }

◆ IsArrayTypeSupported()

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

inlinestatic

Definition at line 3265 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 3193 of file il.h.

3193{ 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

Definition at line 3165 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 3189 of file il.h.

3189{ return inputs_[kSrcPos]; }

◆ src_cid()

classid_t dart::MemoryCopyInstr::src_cid ( ) const

inline

Definition at line 3195 of file il.h.

3195{ return src_cid_; }

◆ src_start()

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

inline

Definition at line 3191 of file il.h.

3191{ return inputs_[kSrcStartPos]; }

◆ unboxed_inputs()

bool dart::MemoryCopyInstr::unboxed_inputs ( ) const

inline

Definition at line 3198 of file il.h.

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