dart::DeferredRetAddr Class Reference

#include <deferred_objects.h>

Inheritance diagram for dart::DeferredRetAddr:

Public Member Functions
	DeferredRetAddr (intptr_t index, intptr_t deopt_id, ObjectPtr *slot, DeferredSlot *next)
virtual void	Materialize (DeoptContext *deopt_context)
intptr_t	index () const
Public Member Functions inherited from dart::DeferredSlot
	DeferredSlot (ObjectPtr *slot, DeferredSlot *next)
virtual	~DeferredSlot ()
ObjectPtr *	slot () const
DeferredSlot *	next () const

Detailed Description

Definition at line 132 of file deferred_objects.h.

Constructor & Destructor Documentation

DeferredRetAddr()

dart::DeferredRetAddr::DeferredRetAddr ( intptr_t  index, intptr_t  deopt_id, ObjectPtr *  slot, DeferredSlot *  next  )

inline

Definition at line 134 of file deferred_objects.h.

      : DeferredSlot(slot, next), index_(index), deopt_id_(deopt_id) {}

Member Function Documentation

index()

intptr_t dart::DeferredRetAddr::index ( ) const

inline

Definition at line 142 of file deferred_objects.h.

{ return index_; }

Materialize()

void dart::DeferredRetAddr::Materialize ( DeoptContext *  deopt_context )

virtual

Implements dart::DeferredSlot.

Definition at line 98 of file deferred_objects.cc.

                                                             {
  Thread* thread = deopt_context->thread();
  Zone* zone = deopt_context->zone();
  Function& function = Function::Handle(zone);
  function ^= deopt_context->ObjectAt(index_);
  const Error& error =
      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, function));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
  const Code& code = Code::Handle(zone, function.unoptimized_code());
 
  uword continue_at_pc =
      code.GetPcForDeoptId(deopt_id_, UntaggedPcDescriptors::kDeopt);
  if (continue_at_pc == 0) {
    FATAL("Can't locate continuation PC for deoptid %" Pd " within %s\n",
          deopt_id_, function.ToFullyQualifiedCString());
  }
  uword* dest_addr = reinterpret_cast<uword*>(slot());
  *dest_addr = continue_at_pc;
 
  if (FLAG_trace_deoptimization_verbose) {
    OS::PrintErr("materializing return addr at 0x%" Px ": 0x%" Px "\n",
                 reinterpret_cast<uword>(slot()), continue_at_pc);
  }
 
  uword pc = code.GetPcForDeoptId(deopt_id_, UntaggedPcDescriptors::kIcCall);
  if (pc != 0) {
    // If the deoptimization happened at an IC call, update the IC data
    // to avoid repeated deoptimization at the same site next time around.
    // We cannot use CodePatcher::GetInstanceCallAt because the call site
    // may have switched to from referencing an ICData to a target Code or
    // MegamorphicCache.
    ICData& ic_data = ICData::Handle(zone, function.FindICData(deopt_id_));
    ic_data.AddDeoptReason(deopt_context->deopt_reason());
    // Propagate the reason to all ICData-s with same deopt_id since
    // only unoptimized-code ICData (IC calls) are propagated.
    function.SetDeoptReasonForAll(ic_data.deopt_id(),
                                  deopt_context->deopt_reason());
  } else {
    if (deopt_context->HasDeoptFlag(ICData::kHoisted)) {
      // Prevent excessive deoptimization.
      function.SetProhibitsInstructionHoisting(true);
    }
 
    if (deopt_context->HasDeoptFlag(ICData::kGeneralized)) {
      function.SetProhibitsBoundsCheckGeneralization(true);
    }
  }
}

---

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

• third_party/dart-lang/sdk/runtime/vm/deferred_objects.h
• third_party/dart-lang/sdk/runtime/vm/deferred_objects.cc