dart::ExceptionHandlerFinder Class Reference

Inheritance diagram for dart::ExceptionHandlerFinder:

Public Member Functions
	ExceptionHandlerFinder (Thread *thread)
bool	Find ()
void	PrepareFrameForCatchEntry ()
void	ExecuteCatchEntryMoves (const CatchEntryMoves &moves)
void	GetCatchEntryMovesFromDeopt (intptr_t num_vars, StackFrame *frame)
Public Member Functions inherited from dart::StackResource
	StackResource (ThreadState *thread)
virtual	~StackResource ()
ThreadState *	thread () const

Public Attributes
bool	needs_stacktrace
uword	handler_pc
uword	handler_sp
uword	handler_fp

Additional Inherited Members
Static Public Member Functions inherited from dart::StackResource
static void	Unwind (ThreadState *thread)
static void	UnwindAbove (ThreadState *thread, StackResource *new_top)

Detailed Description

Definition at line 119 of file exceptions.cc.

Constructor & Destructor Documentation

ExceptionHandlerFinder()

dart::ExceptionHandlerFinder::ExceptionHandlerFinder ( Thread *  thread )

inlineexplicit

Definition at line 121 of file exceptions.cc.

      : StackResource(thread), thread_(thread) {}

Member Function Documentation

ExecuteCatchEntryMoves()

void dart::ExceptionHandlerFinder::ExecuteCatchEntryMoves ( const CatchEntryMoves &  moves )

inline

Definition at line 218 of file exceptions.cc.

                                                            {
    Zone* zone = Thread::Current()->zone();
    auto& value = Object::Handle(zone);
    GrowableArray<Object*> dst_values;
 
    uword fp = handler_fp;
    ObjectPool* pool = nullptr;
    for (int j = 0; j < moves.count(); j++) {
      const CatchEntryMove& move = moves.At(j);
 
      switch (move.source_kind()) {
        case CatchEntryMove::SourceKind::kConstant:
          if (pool == nullptr) {
            pool = &ObjectPool::Handle(code_->GetObjectPool());
          }
          value = pool->ObjectAt(move.src_slot());
          break;
 
        case CatchEntryMove::SourceKind::kTaggedSlot:
          value = *TaggedSlotAt(fp, move.src_slot());
          break;
 
        case CatchEntryMove::SourceKind::kFloatSlot:
          value = Double::New(*SlotAt<float>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kDoubleSlot:
          value = Double::New(*SlotAt<double>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kFloat32x4Slot:
          value = Float32x4::New(*SlotAt<simd128_value_t>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kFloat64x2Slot:
          value = Float64x2::New(*SlotAt<simd128_value_t>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kInt32x4Slot:
          value = Int32x4::New(*SlotAt<simd128_value_t>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kInt64PairSlot:
          value = Integer::New(
              Utils::LowHighTo64Bits(*SlotAt<uint32_t>(fp, move.src_lo_slot()),
                                     *SlotAt<int32_t>(fp, move.src_hi_slot())));
          break;
 
        case CatchEntryMove::SourceKind::kInt64Slot:
          value = Integer::New(*SlotAt<int64_t>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kInt32Slot:
          value = Integer::New(*SlotAt<int32_t>(fp, move.src_slot()));
          break;
 
        case CatchEntryMove::SourceKind::kUint32Slot:
          value = Integer::New(*SlotAt<uint32_t>(fp, move.src_slot()));
          break;
 
        default:
          UNREACHABLE();
      }
 
      dst_values.Add(&Object::Handle(zone, value.ptr()));
    }
 
    {
      Thread* thread = Thread::Current();
      NoSafepointScope no_safepoint_scope(thread);
 
      for (int j = 0; j < moves.count(); j++) {
        const CatchEntryMove& move = moves.At(j);
        *TaggedSlotAt(fp, move.dest_slot()) = dst_values[j]->ptr();
      }
 
      // Update the return address in the stack so the correct stack map is used
      // for any stack walks that happen before we jump to the handler.
      StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread,
                                StackFrameIterator::kNoCrossThreadIteration);
      bool found = false;
      for (StackFrame* frame = frames.NextFrame(); frame != nullptr;
           frame = frames.NextFrame()) {
        if (frame->fp() == handler_fp) {
          ASSERT_EQUAL(frame->pc(), static_cast<uword>(pc_));
          frame->set_pc(handler_pc);
          found = true;
          break;
        }
      }
      ASSERT(found);
    }
  }

Find()

bool dart::ExceptionHandlerFinder::Find ( )

inline

Definition at line 128 of file exceptions.cc.

              {
    StackFrameIterator frames(ValidationPolicy::kDontValidateFrames,
                              Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* frame = frames.NextFrame();
    if (frame == nullptr) return false;  // No Dart frame.
    handler_pc_set_ = false;
    needs_stacktrace = false;
    bool is_catch_all = false;
    uword temp_handler_pc = kUwordMax;
    bool is_optimized = false;
    code_ = nullptr;
    catch_entry_moves_cache_ = thread_->isolate()->catch_entry_moves_cache();
 
    while (!frame->IsEntryFrame()) {
      if (frame->IsDartFrame()) {
        if (frame->FindExceptionHandler(thread_, &temp_handler_pc,
                                        &needs_stacktrace, &is_catch_all,
                                        &is_optimized)) {
          if (!handler_pc_set_) {
            handler_pc_set_ = true;
            handler_pc = temp_handler_pc;
            handler_sp = frame->sp();
            handler_fp = frame->fp();
            if (is_optimized &&
                (handler_pc !=
                 StubCode::AsyncExceptionHandler().EntryPoint())) {
              pc_ = frame->pc();
              code_ = &Code::Handle(frame->LookupDartCode());
              CatchEntryMovesRefPtr* cached_catch_entry_moves =
                  catch_entry_moves_cache_->Lookup(pc_);
              if (cached_catch_entry_moves != nullptr) {
                cached_catch_entry_moves_ = *cached_catch_entry_moves;
              }
              if (cached_catch_entry_moves_.IsEmpty()) {
#if defined(DART_PRECOMPILED_RUNTIME)
                // Only AOT mode is supported.
                ReadCompressedCatchEntryMoves();
#elif defined(DART_PRECOMPILER)
                // Both AOT and JIT modes are supported.
                if (FLAG_precompiled_mode) {
                  ReadCompressedCatchEntryMoves();
                } else {
                  GetCatchEntryMovesFromDeopt(code_->num_variables(), frame);
                }
#else
                // Only JIT mode is supported.
                ASSERT(!FLAG_precompiled_mode);
                GetCatchEntryMovesFromDeopt(code_->num_variables(), frame);
#endif
              }
            }
          }
          if (needs_stacktrace || is_catch_all) {
            return true;
          }
        }
      }  // if frame->IsDartFrame
      frame = frames.NextFrame();
      ASSERT(frame != nullptr);
    }  // while !frame->IsEntryFrame
    ASSERT(frame->IsEntryFrame());
    if (!handler_pc_set_) {
      handler_pc = frame->pc();
      handler_sp = frame->sp();
      handler_fp = frame->fp();
    }
    // No catch-all encountered, needs stacktrace.
    needs_stacktrace = true;
    return handler_pc_set_;
  }

GetCatchEntryMovesFromDeopt()

void dart::ExceptionHandlerFinder::GetCatchEntryMovesFromDeopt ( intptr_t  num_vars, StackFrame *  frame  )

inline

Definition at line 323 of file exceptions.cc.

                                                                         {
    Isolate* isolate = thread_->isolate();
    DeoptContext* deopt_context =
        new DeoptContext(frame, *code_, DeoptContext::kDestIsAllocated, nullptr,
                         nullptr, true, false /* deoptimizing_code */);
    isolate->set_deopt_context(deopt_context);
 
    catch_entry_moves_ = deopt_context->ToCatchEntryMoves(num_vars);
 
    isolate->set_deopt_context(nullptr);
    delete deopt_context;
  }

PrepareFrameForCatchEntry()

void dart::ExceptionHandlerFinder::PrepareFrameForCatchEntry ( )

inline

Definition at line 203 of file exceptions.cc.

                                   {
    if (code_ == nullptr || !code_->is_optimized()) {
      return;
    }
 
    if (cached_catch_entry_moves_.IsEmpty()) {
      catch_entry_moves_cache_->Insert(
          pc_, CatchEntryMovesRefPtr(catch_entry_moves_));
    } else {
      catch_entry_moves_ = &cached_catch_entry_moves_.moves();
    }
 
    ExecuteCatchEntryMoves(*catch_entry_moves_);
  }

Member Data Documentation

handler_fp

uword dart::ExceptionHandlerFinder::handler_fp

Definition at line 340 of file exceptions.cc.

handler_pc

uword dart::ExceptionHandlerFinder::handler_pc

Definition at line 338 of file exceptions.cc.

handler_sp

uword dart::ExceptionHandlerFinder::handler_sp

Definition at line 339 of file exceptions.cc.

needs_stacktrace

bool dart::ExceptionHandlerFinder::needs_stacktrace

Definition at line 337 of file exceptions.cc.

---

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

• third_party/dart-lang/sdk/runtime/vm/exceptions.cc