dart::ExceptionHandlerList Class Reference

#include <code_descriptors.h>

Inheritance diagram for dart::ExceptionHandlerList:

Classes
struct	HandlerDesc

Public Member Functions
	ExceptionHandlerList (const Function &function)
intptr_t	Length () const
void	AddPlaceHolder ()
void	AddHandler (intptr_t try_index, intptr_t outer_try_index, intptr_t pc_offset, bool is_generated, const Array &handler_types, bool needs_stacktrace)
void	SetNeedsStackTrace (intptr_t try_index)
ExceptionHandlersPtr	FinalizeExceptionHandlers (uword entry_point) 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	ContainsCatchAllType (const Array &array)

Detailed Description

Definition at line 69 of file code_descriptors.h.

Constructor & Destructor Documentation

ExceptionHandlerList()

dart::ExceptionHandlerList::ExceptionHandlerList ( const Function &  function )

inlineexplicit

Definition at line 79 of file code_descriptors.h.

      : list_(),
        has_async_handler_(function.IsAsyncFunction() ||
                           function.IsAsyncGenerator()) {}

Member Function Documentation

AddHandler()

void dart::ExceptionHandlerList::AddHandler ( intptr_t  try_index, intptr_t  outer_try_index, intptr_t  pc_offset, bool  is_generated, const Array &  handler_types, bool  needs_stacktrace  )

inline

Definition at line 96 of file code_descriptors.h.

                                         {
    ASSERT(try_index >= 0);
    while (Length() <= try_index) {
      AddPlaceHolder();
    }
    list_[try_index].outer_try_index = outer_try_index;
    ASSERT(list_[try_index].pc_offset == ExceptionHandlers::kInvalidPcOffset);
    list_[try_index].pc_offset = pc_offset;
    list_[try_index].is_generated = is_generated;
    DEBUG_ASSERT(handler_types.IsNotTemporaryScopedHandle());
    list_[try_index].handler_types = &handler_types;
    list_[try_index].needs_stacktrace |= needs_stacktrace;
  }

AddPlaceHolder()

void dart::ExceptionHandlerList::AddPlaceHolder ( )

inline

Definition at line 86 of file code_descriptors.h.

                        {
    struct HandlerDesc data;
    data.outer_try_index = -1;
    data.pc_offset = ExceptionHandlers::kInvalidPcOffset;
    data.is_generated = true;
    data.handler_types = nullptr;
    data.needs_stacktrace = false;
    list_.Add(data);
  }

ContainsCatchAllType()

static bool dart::ExceptionHandlerList::ContainsCatchAllType ( const Array &  array )

inlinestatic

Definition at line 128 of file code_descriptors.h.

                                                       {
    auto& type = AbstractType::Handle();
    for (intptr_t i = 0; i < array.Length(); i++) {
      type ^= array.At(i);
      if (type.IsCatchAllType()) {
        return true;
      }
    }
    return false;
  }

FinalizeExceptionHandlers()

ExceptionHandlersPtr dart::ExceptionHandlerList::FinalizeExceptionHandlers

(

uword

entry_point

)

const

Definition at line 124 of file code_descriptors.cc.

                             {
  intptr_t num_handlers = Length();
  if (num_handlers == 0) {
    return has_async_handler_ ? Object::empty_async_exception_handlers().ptr()
                              : Object::empty_exception_handlers().ptr();
  }
  const ExceptionHandlers& handlers =
      ExceptionHandlers::Handle(ExceptionHandlers::New(num_handlers));
  handlers.set_has_async_handler(has_async_handler_);
  for (intptr_t i = 0; i < num_handlers; i++) {
    // Assert that every element in the array has been initialized.
    if (list_[i].handler_types == nullptr) {
      // Unreachable handler, entry not computed.
      // Initialize it to some meaningful value.
      const bool has_catch_all = false;
      // Check it is uninitialized.
      ASSERT((list_[i].outer_try_index == -1) &&
             (list_[i].pc_offset == ExceptionHandlers::kInvalidPcOffset));
      handlers.SetHandlerInfo(i, list_[i].outer_try_index, list_[i].pc_offset,
                              list_[i].needs_stacktrace, has_catch_all,
                              list_[i].is_generated);
      handlers.SetHandledTypes(i, Array::empty_array());
    } else {
      const bool has_catch_all = ContainsCatchAllType(*list_[i].handler_types);
      handlers.SetHandlerInfo(i, list_[i].outer_try_index, list_[i].pc_offset,
                              list_[i].needs_stacktrace, has_catch_all,
                              list_[i].is_generated);
      handlers.SetHandledTypes(i, *list_[i].handler_types);
    }
  }
  return handlers.ptr();
}

Length()

intptr_t dart::ExceptionHandlerList::Length ( ) const

inline

Definition at line 84 of file code_descriptors.h.

{ return list_.length(); }

SetNeedsStackTrace()

void dart::ExceptionHandlerList::SetNeedsStackTrace ( intptr_t  try_index )

inline

Definition at line 116 of file code_descriptors.h.

                                              {
    // Rethrows can be generated outside a try by the compiler.
    if (try_index == kInvalidTryIndex) {
      return;
    }
    ASSERT(try_index >= 0);
    while (Length() <= try_index) {
      AddPlaceHolder();
    }
    list_[try_index].needs_stacktrace = true;
  }

---

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

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