#include <deopt_instructions.h>

Inheritance diagram for dart::DeoptContext:

Public Types
enum	DestFrameOptions { kDestIsOriginalFrame , kDestIsAllocated }

Public Member Functions
	DeoptContext (const StackFrame frame, const Code &code, DestFrameOptions dest_options, fpu_register_t fpu_registers, intptr_t *cpu_registers, bool is_lazy_deopt, bool deoptimizing_code)

virtual	~DeoptContext ()

intptr_t	DestStackAdjustment () const

intptr_t *	GetSourceFrameAddressAt (intptr_t index) const

intptr_t	GetStackSlot (intptr_t index) const

intptr_t	GetSourceFp () const

intptr_t	GetSourcePp () const

intptr_t	GetSourcePc () const

intptr_t	GetCallerFp () const

void	SetCallerFp (intptr_t callers_fp)

ObjectPtr	ObjectAt (intptr_t index) const

intptr_t	RegisterValue (Register reg) const

float	FpuRegisterValueAsFloat (FpuRegister reg) const

double	FpuRegisterValueAsDouble (FpuRegister reg) const

simd128_value_t	FpuRegisterValueAsSimd128 (FpuRegister reg) const

intptr_t *	FrameBase (const StackFrame *frame)

void	set_dest_frame (const StackFrame *frame)

Thread *	thread () const

Zone *	zone () const

intptr_t	source_frame_size () const

intptr_t	dest_frame_size () const

CodePtr	code () const

bool	is_lazy_deopt () const

bool	deoptimizing_code () const

ICData::DeoptReasonId	deopt_reason () const

bool	HasDeoptFlag (ICData::DeoptFlags flag)

TypedDataPtr	deopt_info () const

void	FillDestFrame ()

const CatchEntryMoves *	ToCatchEntryMoves (intptr_t num_vars)

intptr_t	MaterializeDeferredObjects ()

ArrayPtr	DestFrameAsArray ()

void	VisitObjectPointers (ObjectPointerVisitor *visitor)

void	DeferMaterializedObjectRef (intptr_t idx, intptr_t *slot)

void	DeferMaterialization (float value, DoublePtr *slot)

void	DeferMaterialization (double value, DoublePtr *slot)

void	DeferMintMaterialization (int64_t value, MintPtr *slot)

void	DeferMaterialization (simd128_value_t value, Float32x4Ptr *slot)

void	DeferMaterialization (simd128_value_t value, Float64x2Ptr *slot)

void	DeferMaterialization (simd128_value_t value, Int32x4Ptr *slot)

void	DeferRetAddrMaterialization (intptr_t index, intptr_t deopt_id, intptr_t *slot)

void	DeferPcMarkerMaterialization (intptr_t index, intptr_t *slot)

void	DeferPpMaterialization (intptr_t index, ObjectPtr *slot)

DeferredObject *	GetDeferredObject (intptr_t idx) const

intptr_t	num_args () const

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

void *	operator new (size_t size)

void *	operator new[] (size_t size)

void	operator delete (void *pointer)

void	operator delete[] (void *pointer)

Detailed Description

Definition at line 30 of file deopt_instructions.h.

Member Enumeration Documentation

◆ DestFrameOptions

enum dart::DeoptContext::DestFrameOptions

Enumerator
kDestIsOriginalFrame
kDestIsAllocated

Definition at line 32 of file deopt_instructions.h.

                        {
    kDestIsOriginalFrame,  // Replace the original frame with deopt frame.
    kDestIsAllocated       // Write deopt frame to a buffer.
  };

Constructor & Destructor Documentation

◆ DeoptContext()

dart::DeoptContext::DeoptContext	(	const StackFrame *	frame,
		const Code &	code,
		DestFrameOptions	dest_options,
		fpu_register_t *	fpu_registers,
		intptr_t *	cpu_registers,
		bool	is_lazy_deopt,
		bool	deoptimizing_code
	)

Definition at line 29 of file deopt_instructions.cc.

    : code_(code.ptr()),
      object_pool_(code.GetObjectPool()),
      deopt_info_(TypedData::null()),
      dest_frame_is_allocated_(false),
      dest_frame_(nullptr),
      dest_frame_size_(0),
      source_frame_is_allocated_(false),
      source_frame_(nullptr),
      source_frame_size_(0),
      cpu_registers_(cpu_registers),
      fpu_registers_(fpu_registers),
      num_args_(0),
      deopt_reason_(ICData::kDeoptUnknown),
      deopt_flags_(0),
      thread_(Thread::Current()),
      deopt_start_micros_(0),
      deferred_slots_(nullptr),
      deferred_objects_count_(0),
      deferred_objects_(nullptr),
      is_lazy_deopt_(is_lazy_deopt),
      deoptimizing_code_(deoptimizing_code) {
  const TypedData& deopt_info = TypedData::Handle(
      code.GetDeoptInfoAtPc(frame->pc(), &deopt_reason_, &deopt_flags_));
#if defined(DEBUG)
  if (deopt_info.IsNull()) {
    OS::PrintErr("Missing deopt info for pc %" Px "\n", frame->pc());
    DisassembleToStdout formatter;
    code.Disassemble(&formatter);
  }
#endif
  ASSERT(!deopt_info.IsNull());
  deopt_info_ = deopt_info.ptr();
 
  const Function& function = Function::Handle(code.function());
 
  // Do not include incoming arguments if there are optional arguments
  // (they are copied into local space at method entry).
  num_args_ =
      function.MakesCopyOfParameters() ? 0 : function.num_fixed_parameters();
 
  // The fixed size section of the (fake) Dart frame called via a stub by the
  // optimized function contains FP, PP (ARM only), PC-marker and
  // return-address. This section is copied as well, so that its contained
  // values can be updated before returning to the deoptimized function.
  ASSERT(frame->fp() >= frame->sp());
  const intptr_t frame_size = (frame->fp() - frame->sp()) / kWordSize;
 
  source_frame_size_ = +kDartFrameFixedSize   // For saved values below sp.
                       + frame_size           // For frame size incl. sp.
                       + 1                    // For fp.
                       + kParamEndSlotFromFp  // For saved values above fp.
                       + num_args_;           // For arguments.
 
  source_frame_ = FrameBase(frame);
 
  if (dest_options == kDestIsOriginalFrame) {
    // Work from a copy of the source frame.
    intptr_t* original_frame = source_frame_;
    source_frame_ = new intptr_t[source_frame_size_];
    ASSERT(source_frame_ != nullptr);
    for (intptr_t i = 0; i < source_frame_size_; i++) {
      source_frame_[i] = original_frame[i];
    }
    source_frame_is_allocated_ = true;
  }
  caller_fp_ = GetSourceFp();
 
  dest_frame_size_ = DeoptInfo::FrameSize(deopt_info);
 
  if (dest_options == kDestIsAllocated) {
    dest_frame_ = new intptr_t[dest_frame_size_];
    ASSERT(source_frame_ != nullptr);
    for (intptr_t i = 0; i < dest_frame_size_; i++) {
      dest_frame_[i] = 0;
    }
    dest_frame_is_allocated_ = true;
  }
 
  if (dest_options != kDestIsAllocated) {
    // kDestIsAllocated is used by the debugger to generate a stack trace
    // and does not signal a real deopt.
    deopt_start_micros_ = OS::GetCurrentMonotonicMicros();
  }
 
  if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
    THR_Print(
        "Deoptimizing (reason %d '%s') at "
        "pc=%" Pp " fp=%" Pp " '%s' (count %d)\n",
        deopt_reason(), DeoptReasonToCString(deopt_reason()), frame->pc(),
        frame->fp(), function.ToFullyQualifiedCString(),
        function.deoptimization_counter());
  }
}

◆ ~DeoptContext()

dart::DeoptContext::~DeoptContext ( )

virtual

Definition at line 130 of file deopt_instructions.cc.

                            {
  // Delete memory for source frame and registers.
  if (source_frame_is_allocated_) {
    delete[] source_frame_;
  }
  source_frame_ = nullptr;
  delete[] fpu_registers_;
  delete[] cpu_registers_;
  fpu_registers_ = nullptr;
  cpu_registers_ = nullptr;
  if (dest_frame_is_allocated_) {
    delete[] dest_frame_;
  }
  dest_frame_ = nullptr;
 
  // Delete all deferred objects.
  for (intptr_t i = 0; i < deferred_objects_count_; i++) {
    delete deferred_objects_[i];
  }
  delete[] deferred_objects_;
  deferred_objects_ = nullptr;
  deferred_objects_count_ = 0;
 
#if defined(SUPPORT_TIMELINE)
  if (deopt_start_micros_ != 0) {
    TimelineStream* compiler_stream = Timeline::GetCompilerStream();
    ASSERT(compiler_stream != nullptr);
    if (compiler_stream->enabled()) {
      // Allocate all Dart objects needed before calling StartEvent,
      // which blocks safe points until Complete is called.
      const Code& code = Code::Handle(zone(), code_);
      const Function& function = Function::Handle(zone(), code.function());
      const String& function_name =
          String::Handle(zone(), function.QualifiedScrubbedName());
      const char* reason = DeoptReasonToCString(deopt_reason());
      const int counter = function.deoptimization_counter();
      TimelineEvent* timeline_event = compiler_stream->StartEvent();
      if (timeline_event != nullptr) {
        timeline_event->Duration("Deoptimize", deopt_start_micros_,
                                 OS::GetCurrentMonotonicMicros());
        timeline_event->SetNumArguments(3);
        timeline_event->CopyArgument(0, "function", function_name.ToCString());
        timeline_event->CopyArgument(1, "reason", reason);
        timeline_event->FormatArgument(2, "deoptimizationCount", "%d", counter);
        timeline_event->Complete();
      }
    }
  }
#endif  // !PRODUCT
}

Member Function Documentation

◆ code()

CodePtr dart::DeoptContext::code ( ) const

inline

Definition at line 135 of file deopt_instructions.h.

135{ return code_; }

◆ DeferMaterialization() [1/5]

void dart::DeoptContext::DeferMaterialization	(	double	value,
		DoublePtr *	slot
	)

inline

Definition at line 175 of file deopt_instructions.h.

                                                           {
    deferred_slots_ = new DeferredDouble(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMaterialization() [2/5]

void dart::DeoptContext::DeferMaterialization	(	float	value,
		DoublePtr *	slot
	)

inline

Definition at line 170 of file deopt_instructions.h.

                                                          {
    deferred_slots_ = new DeferredDouble(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMaterialization() [3/5]

void dart::DeoptContext::DeferMaterialization	(	simd128_value_t	value,
		Float32x4Ptr *	slot
	)

inline

Definition at line 185 of file deopt_instructions.h.

                                                                       {
    deferred_slots_ = new DeferredFloat32x4(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMaterialization() [4/5]

void dart::DeoptContext::DeferMaterialization	(	simd128_value_t	value,
		Float64x2Ptr *	slot
	)

inline

Definition at line 190 of file deopt_instructions.h.

                                                                       {
    deferred_slots_ = new DeferredFloat64x2(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMaterialization() [5/5]

void dart::DeoptContext::DeferMaterialization	(	simd128_value_t	value,
		Int32x4Ptr *	slot
	)

inline

Definition at line 195 of file deopt_instructions.h.

                                                                     {
    deferred_slots_ = new DeferredInt32x4(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMaterializedObjectRef()

void dart::DeoptContext::DeferMaterializedObjectRef	(	intptr_t	idx,
		intptr_t *	slot
	)

inline

Definition at line 165 of file deopt_instructions.h.

                                                                {
    deferred_slots_ = new DeferredObjectRef(
        idx, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferMintMaterialization()

void dart::DeoptContext::DeferMintMaterialization	(	int64_t	value,
		MintPtr *	slot
	)

inline

Definition at line 180 of file deopt_instructions.h.

                                                              {
    deferred_slots_ = new DeferredMint(
        value, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferPcMarkerMaterialization()

void dart::DeoptContext::DeferPcMarkerMaterialization	(	intptr_t	index,
		intptr_t *	slot
	)

inline

Definition at line 207 of file deopt_instructions.h.

                                                                    {
    deferred_slots_ = new DeferredPcMarker(
        index, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ DeferPpMaterialization()

void dart::DeoptContext::DeferPpMaterialization	(	intptr_t	index,
		ObjectPtr *	slot
	)

inline

Definition at line 212 of file deopt_instructions.h.

                                                               {
    deferred_slots_ = new DeferredPp(index, slot, deferred_slots_);
  }

◆ DeferRetAddrMaterialization()

void dart::DeoptContext::DeferRetAddrMaterialization	(	intptr_t	index,
		intptr_t	deopt_id,
		intptr_t *	slot
	)

inline

Definition at line 200 of file deopt_instructions.h.

                                                   {
    deferred_slots_ = new DeferredRetAddr(
        index, deopt_id, reinterpret_cast<ObjectPtr*>(slot), deferred_slots_);
  }

◆ deopt_info()

TypedDataPtr dart::DeoptContext::deopt_info ( ) const

inline

Definition at line 146 of file deopt_instructions.h.

146{ return deopt_info_; }

◆ deopt_reason()

ICData::DeoptReasonId dart::DeoptContext::deopt_reason ( ) const

inline

Definition at line 141 of file deopt_instructions.h.

141{ return deopt_reason_; }

◆ deoptimizing_code()

bool dart::DeoptContext::deoptimizing_code ( ) const

inline

Definition at line 139 of file deopt_instructions.h.

139{ return deoptimizing_code_; }

◆ dest_frame_size()

intptr_t dart::DeoptContext::dest_frame_size ( ) const

inline

Definition at line 133 of file deopt_instructions.h.

133{ return dest_frame_size_; }

◆ DestFrameAsArray()

ArrayPtr dart::DeoptContext::DestFrameAsArray ( )

Definition at line 400 of file deopt_instructions.cc.

                                        {
  ASSERT(dest_frame_ != nullptr && dest_frame_is_allocated_);
  const Array& dest_array = Array::Handle(zone(), Array::New(dest_frame_size_));
  PassiveObject& obj = PassiveObject::Handle(zone());
  for (intptr_t i = 0; i < dest_frame_size_; i++) {
    obj = static_cast<ObjectPtr>(dest_frame_[i]);
    dest_array.SetAt(i, obj);
  }
  return dest_array.ptr();
}

◆ DestStackAdjustment()

intptr_t dart::DeoptContext::DestStackAdjustment ( ) const

Definition at line 196 of file deopt_instructions.cc.

                                                 {
  return dest_frame_size_ - kDartFrameFixedSize - num_args_ - 1  // For fp.
         - kParamEndSlotFromFp;
}

◆ FillDestFrame()

void dart::DeoptContext::FillDestFrame ( )

Definition at line 258 of file deopt_instructions.cc.

                                 {
  const Code& code = Code::Handle(code_);
  const TypedData& deopt_info = TypedData::Handle(deopt_info_);
 
  GrowableArray<DeoptInstr*> deopt_instructions;
  const Array& deopt_table = Array::Handle(code.deopt_info_array());
  ASSERT(!deopt_table.IsNull());
  DeoptInfo::Unpack(deopt_table, deopt_info, &deopt_instructions);
 
  const intptr_t len = deopt_instructions.length();
  const intptr_t frame_size = dest_frame_size_;
 
  // For now, we never place non-objects in the deoptimized frame if
  // the destination frame is a copy.  This allows us to copy the
  // deoptimized frame into an Array.
  const bool objects_only = dest_frame_is_allocated_;
 
  // All kMaterializeObject instructions are emitted before the instructions
  // that describe stack frames. Skip them and defer materialization of
  // objects until the frame is fully reconstructed and it is safe to perform
  // GC.
  // Arguments (class of the instance to allocate and field-value pairs) are
  // described as part of the expression stack for the bottom-most deoptimized
  // frame. They will be used during materialization and removed from the stack
  // right before control switches to the unoptimized code.
  const intptr_t num_materializations =
      DeoptInfo::NumMaterializations(deopt_instructions);
  PrepareForDeferredMaterialization(num_materializations);
  for (intptr_t from_index = 0, to_index = kDartFrameFixedSize;
       from_index < num_materializations; from_index++) {
    const intptr_t field_count =
        DeoptInstr::GetFieldCount(deopt_instructions[from_index]);
    intptr_t* args = GetDestFrameAddressAt(to_index);
    DeferredObject* obj = new DeferredObject(field_count, args);
    SetDeferredObjectAt(from_index, obj);
    to_index += obj->ArgumentCount();
  }
 
  // Populate stack frames.
  for (intptr_t to_index = frame_size - 1, from_index = len - 1; to_index >= 0;
       to_index--, from_index--) {
    intptr_t* to_addr = GetDestFrameAddressAt(to_index);
    DeoptInstr* instr = deopt_instructions[from_index];
    if (!objects_only || IsObjectInstruction(instr->kind())) {
      instr->Execute(this, to_addr);
    } else {
      *reinterpret_cast<ObjectPtr*>(to_addr) = Object::null();
    }
  }
 
  if (FLAG_trace_deoptimization_verbose) {
    for (intptr_t i = 0; i < frame_size; i++) {
      intptr_t* to_addr = GetDestFrameAddressAt(i);
      THR_Print("*%" Pd ". [%p] 0x%" Px " [%s]\n", i, to_addr, *to_addr,
                deopt_instructions[i + (len - frame_size)]->ToCString());
    }
  }
}

◆ FpuRegisterValueAsDouble()

double dart::DeoptContext::FpuRegisterValueAsDouble ( FpuRegister reg ) const

inline

Definition at line 93 of file deopt_instructions.h.

                                                         {
    ASSERT(FlowGraphCompiler::SupportsUnboxedDoubles());
    ASSERT(fpu_registers_ != nullptr);
    ASSERT(reg >= 0);
    ASSERT(reg < kNumberOfFpuRegisters);
    return *reinterpret_cast<double*>(&fpu_registers_[reg]);
  }

◆ FpuRegisterValueAsFloat()

float dart::DeoptContext::FpuRegisterValueAsFloat ( FpuRegister reg ) const

inline

Definition at line 85 of file deopt_instructions.h.

                                                       {
    ASSERT(FlowGraphCompiler::SupportsUnboxedDoubles());
    ASSERT(fpu_registers_ != NULL);
    ASSERT(reg >= 0);
    ASSERT(reg < kNumberOfFpuRegisters);
    return *reinterpret_cast<float*>(&fpu_registers_[reg]);
  }

◆ FpuRegisterValueAsSimd128()

simd128_value_t dart::DeoptContext::FpuRegisterValueAsSimd128 ( FpuRegister reg ) const

inline

Definition at line 101 of file deopt_instructions.h.

                                                                   {
    ASSERT(FlowGraphCompiler::SupportsUnboxedSimd128());
    ASSERT(fpu_registers_ != nullptr);
    ASSERT(reg >= 0);
    ASSERT(reg < kNumberOfFpuRegisters);
    const float* address = reinterpret_cast<float*>(&fpu_registers_[reg]);
    return simd128_value_t().readFrom(address);
  }

◆ FrameBase()

intptr_t * dart::DeoptContext::FrameBase ( const StackFrame * frame )

inline

Definition at line 117 of file deopt_instructions.h.

                                               {
    // SP of the deoptimization frame is the lowest slot because
    // stack is growing downwards.
    return reinterpret_cast<intptr_t*>(frame->sp() -
                                       (kDartFrameFixedSize * kWordSize));
  }

◆ GetCallerFp()

intptr_t dart::DeoptContext::GetCallerFp ( ) const

Definition at line 216 of file deopt_instructions.cc.

                                         {
  return caller_fp_;
}

◆ GetDeferredObject()

DeferredObject * dart::DeoptContext::GetDeferredObject ( intptr_t idx ) const

inline

Definition at line 216 of file deopt_instructions.h.

                                                        {
    return deferred_objects_[idx];
  }

◆ GetSourceFp()

intptr_t dart::DeoptContext::GetSourceFp ( ) const

Definition at line 201 of file deopt_instructions.cc.

                                         {
  return source_frame_[source_frame_size_ - 1 - num_args_ -
                       kParamEndSlotFromFp + kSavedCallerFpSlotFromFp];
}

◆ GetSourceFrameAddressAt()

intptr_t * dart::DeoptContext::GetSourceFrameAddressAt ( intptr_t index ) const

inline

Definition at line 51 of file deopt_instructions.h.

                                                          {
    ASSERT(source_frame_ != nullptr);
    ASSERT((0 <= index) && (index < source_frame_size_));
    // Convert FP relative index to SP relative one.
    index = source_frame_size_ - 1 - index;
    return &source_frame_[index];
  }

◆ GetSourcePc()

intptr_t dart::DeoptContext::GetSourcePc ( ) const

Definition at line 212 of file deopt_instructions.cc.

                                         {
  return source_frame_[source_frame_size_ - num_args_ + kSavedPcSlotFromSp];
}

◆ GetSourcePp()

intptr_t dart::DeoptContext::GetSourcePp ( ) const

Definition at line 206 of file deopt_instructions.cc.

                                         {
  return source_frame_[source_frame_size_ - 1 - num_args_ -
                       kParamEndSlotFromFp +
                       StackFrame::SavedCallerPpSlotFromFp()];
}

◆ GetStackSlot()

intptr_t dart::DeoptContext::GetStackSlot ( intptr_t index ) const

inline

Definition at line 60 of file deopt_instructions.h.

                                              {
    ASSERT((0 <= index) && (index < source_frame_size_));
    index -= num_args_;
    return index < 0 ? index : index - kDartFrameFixedSize;
  }

◆ HasDeoptFlag()

bool dart::DeoptContext::HasDeoptFlag ( ICData::DeoptFlags flag )

inline

Definition at line 142 of file deopt_instructions.h.

                                           {
    return (deopt_flags_ & flag) != 0;
  }

◆ is_lazy_deopt()

bool dart::DeoptContext::is_lazy_deopt ( ) const

inline

Definition at line 137 of file deopt_instructions.h.

137{ return is_lazy_deopt_; }

◆ MaterializeDeferredObjects()

intptr_t dart::DeoptContext::MaterializeDeferredObjects ( )

Definition at line 360 of file deopt_instructions.cc.

                                                  {
  // Populate slots with references to all unboxed "primitive" values (doubles,
  // mints, simd) and deferred objects. Deferred objects are only allocated
  // but not filled with data. This is done later because deferred objects
  // can references each other.
  FillDeferredSlots(this, &deferred_slots_);
 
  // Compute total number of artificial arguments used during deoptimization.
  intptr_t deopt_arg_count = 0;
  for (intptr_t i = 0; i < DeferredObjectsCount(); i++) {
    GetDeferredObject(i)->Fill();
    deopt_arg_count += GetDeferredObject(i)->ArgumentCount();
  }
 
  // Since this is the only step where GC can occur during deoptimization,
  // use it to report the source line where deoptimization occurred.
  if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
    DartFrameIterator iterator(Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* top_frame = iterator.NextFrame();
    ASSERT(top_frame != nullptr);
    const Code& code = Code::Handle(top_frame->LookupDartCode());
    const Function& top_function = Function::Handle(code.function());
    const Script& script = Script::Handle(top_function.script());
    const TokenPosition token_pos = code.GetTokenIndexOfPC(top_frame->pc());
    THR_Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
    intptr_t line;
    if (script.GetTokenLocation(token_pos, &line)) {
      String& line_string = String::Handle(script.GetLine(line));
      char line_buffer[80];
      Utils::SNPrint(line_buffer, sizeof(line_buffer), "  Line %" Pd ": '%s'",
                     line, line_string.ToCString());
      THR_Print("%s\n", line_buffer);
    }
    THR_Print("  Deopt args: %" Pd "\n", deopt_arg_count);
  }
 
  return deopt_arg_count;
}

◆ num_args()

intptr_t dart::DeoptContext::num_args ( ) const

inline

Definition at line 220 of file deopt_instructions.h.

220{ return num_args_; }

◆ ObjectAt()

ObjectPtr dart::DeoptContext::ObjectAt ( intptr_t index ) const

inline

Definition at line 73 of file deopt_instructions.h.

                                           {
    const ObjectPool& object_pool = ObjectPool::Handle(object_pool_);
    return object_pool.ObjectAt(index);
  }

◆ RegisterValue()

intptr_t dart::DeoptContext::RegisterValue ( Register reg ) const

inline

Definition at line 78 of file deopt_instructions.h.

                                             {
    ASSERT(reg >= 0);
    ASSERT(reg < kNumberOfCpuRegisters);
    ASSERT(cpu_registers_ != nullptr);
    return cpu_registers_[reg];
  }

◆ set_dest_frame()

void dart::DeoptContext::set_dest_frame ( const StackFrame * frame )

inline

Definition at line 124 of file deopt_instructions.h.

                                               {
    ASSERT(frame != nullptr && dest_frame_ == nullptr);
    dest_frame_ = FrameBase(frame);
  }

◆ SetCallerFp()

void dart::DeoptContext::SetCallerFp ( intptr_t callers_fp )

Definition at line 220 of file deopt_instructions.cc.

                                                 {
  caller_fp_ = caller_fp;
}

◆ source_frame_size()

intptr_t dart::DeoptContext::source_frame_size ( ) const

inline

Definition at line 132 of file deopt_instructions.h.

132{ return source_frame_size_; }

◆ thread()

Thread * dart::DeoptContext::thread ( ) const

inline

Definition at line 129 of file deopt_instructions.h.

129{ return thread_; }

◆ ToCatchEntryMoves()

const CatchEntryMoves * dart::DeoptContext::ToCatchEntryMoves ( intptr_t num_vars )

Definition at line 317 of file deopt_instructions.cc.

                                                                        {
  const Code& code = Code::Handle(code_);
  const TypedData& deopt_info = TypedData::Handle(deopt_info_);
  GrowableArray<DeoptInstr*> deopt_instructions;
  const Array& deopt_table = Array::Handle(code.deopt_info_array());
  ASSERT(!deopt_table.IsNull());
  DeoptInfo::Unpack(deopt_table, deopt_info, &deopt_instructions);
 
  CatchEntryMoves* moves = CatchEntryMoves::Allocate(num_vars);
 
  Function& function = Function::Handle(zone(), code.function());
  intptr_t params =
      function.MakesCopyOfParameters() ? 0 : function.num_fixed_parameters();
  for (intptr_t i = 0; i < num_vars; i++) {
    const intptr_t len = deopt_instructions.length();
    intptr_t slot = i < params ? i
                               : i + kParamEndSlotFromFp -
                                     runtime_frame_layout.first_local_from_fp;
    DeoptInstr* instr = deopt_instructions[len - 1 - slot];
    intptr_t dest_index = i - params;
    moves->At(i) = instr->ToCatchEntryMove(this, dest_index);
  }
 
  return moves;
}

◆ VisitObjectPointers()

void dart::DeoptContext::VisitObjectPointers ( ObjectPointerVisitor * visitor )

Definition at line 181 of file deopt_instructions.cc.

                                                                    {
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&code_));
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&object_pool_));
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&deopt_info_));
 
  // Visit any object pointers on the destination stack.
  if (dest_frame_is_allocated_) {
    for (intptr_t i = 0; i < dest_frame_size_; i++) {
      if (dest_frame_[i] != 0) {
        visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&dest_frame_[i]));
      }
    }
  }
}

◆ zone()

Zone * dart::DeoptContext::zone ( ) const

inline

Definition at line 130 of file deopt_instructions.h.

130{ return thread_->zone(); }

dart::ThreadState::zone

Zone * zone() const

Definition thread_state.h:37

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

third_party/dart-lang/sdk/runtime/vm/deopt_instructions.h
third_party/dart-lang/sdk/runtime/vm/deopt_instructions.cc

Public Types

Public Member Functions

Detailed Description

Member Enumeration Documentation

◆ DestFrameOptions

Constructor & Destructor Documentation

◆ DeoptContext()

◆ ~DeoptContext()

Member Function Documentation

◆ code()

◆ DeferMaterialization() [1/5]

◆ DeferMaterialization() [2/5]

◆ DeferMaterialization() [3/5]

◆ DeferMaterialization() [4/5]

◆ DeferMaterialization() [5/5]

◆ DeferMaterializedObjectRef()

◆ DeferMintMaterialization()

◆ DeferPcMarkerMaterialization()

◆ DeferPpMaterialization()

◆ DeferRetAddrMaterialization()

◆ deopt_info()

◆ deopt_reason()

◆ deoptimizing_code()

◆ dest_frame_size()

◆ DestFrameAsArray()

◆ DestStackAdjustment()

◆ FillDestFrame()

◆ FpuRegisterValueAsDouble()

◆ FpuRegisterValueAsFloat()

◆ FpuRegisterValueAsSimd128()

◆ FrameBase()

◆ GetCallerFp()

◆ GetDeferredObject()

◆ GetSourceFp()

◆ GetSourceFrameAddressAt()

◆ GetSourcePc()

◆ GetSourcePp()

◆ GetStackSlot()

◆ HasDeoptFlag()

◆ is_lazy_deopt()

◆ MaterializeDeferredObjects()

◆ num_args()

◆ ObjectAt()

◆ RegisterValue()

◆ set_dest_frame()

◆ SetCallerFp()

◆ source_frame_size()

◆ thread()

◆ ToCatchEntryMoves()

◆ VisitObjectPointers()

◆ zone()