dart::Exceptions Class Reference

#include <exceptions.h>

Inheritance diagram for dart::Exceptions:

Public Types
enum	ExceptionType {   kNone , kRange , kRangeMsg , kArgument ,   kArgumentValue , kState , kIntegerDivisionByZeroException , kNoSuchMethod ,   kFormat , kUnsupported , kStackOverflow , kOutOfMemory ,   kIsolateSpawn , kAssertion , kType , kAbstractClassInstantiation ,   kCyclicInitializationError , kCompileTimeError , kLateFieldAssignedDuringInitialization , kLateFieldNotInitialized }

Static Public Member Functions
static DART_NORETURN void	Throw (Thread *thread, const Instance &exception)
static DART_NORETURN void	ReThrow (Thread *thread, const Instance &exception, const Instance &stacktrace, bool bypass_debugger=false)
static DART_NORETURN void	ThrowWithStackTrace (Thread *thread, const Instance &exception, const Instance &stacktrace)
static DART_NORETURN void	PropagateError (const Error &error)
static DART_NORETURN void	PropagateToEntry (const Error &error)
static StackTracePtr	CurrentStackTrace ()
static ScriptPtr	GetCallerScript (DartFrameIterator *iterator)
static InstancePtr	NewInstance (const char *class_name)
static void	CreateAndThrowTypeError (TokenPosition location, const AbstractType &src_type, const AbstractType &dst_type, const String &dst_name)
static DART_NORETURN void	ThrowByType (ExceptionType type, const Array &arguments)
static DART_NORETURN void	ThrowOOM ()
static DART_NORETURN void	ThrowStackOverflow ()
static DART_NORETURN void	ThrowArgumentError (const Instance &arg)
static DART_NORETURN void	ThrowStateError (const Instance &arg)
static DART_NORETURN void	ThrowRangeError (const char *argument_name, const Integer &argument_value, intptr_t expected_from, intptr_t expected_to)
static DART_NORETURN void	ThrowUnsupportedError (const char *msg)
static DART_NORETURN void	ThrowCompileTimeError (const LanguageError &error)
static DART_NORETURN void	ThrowLateFieldAssignedDuringInitialization (const String &name)
static DART_NORETURN void	ThrowLateFieldNotInitialized (const String &name)
static ObjectPtr	Create (ExceptionType type, const Array &arguments)
static UnhandledExceptionPtr	CreateUnhandledException (Zone *zone, ExceptionType type, const char *msg)
static DART_NORETURN void	JumpToFrame (Thread *thread, uword program_counter, uword stack_pointer, uword frame_pointer, bool clear_deopt_at_target)

Detailed Description

Definition at line 29 of file exceptions.h.

Member Enumeration Documentation

ExceptionType

enum dart::Exceptions::ExceptionType

Enumerator
kNone
kRange
kRangeMsg
kArgument
kArgumentValue
kState
kIntegerDivisionByZeroException
kNoSuchMethod
kFormat
kUnsupported
kStackOverflow
kOutOfMemory
kIsolateSpawn
kAssertion
kType
kAbstractClassInstantiation
kCyclicInitializationError
kCompileTimeError
kLateFieldAssignedDuringInitialization
kLateFieldNotInitialized

Definition at line 53 of file exceptions.h.

                     {
    kNone,
    kRange,
    kRangeMsg,
    kArgument,
    kArgumentValue,
    kState,
    kIntegerDivisionByZeroException,
    kNoSuchMethod,
    kFormat,
    kUnsupported,
    kStackOverflow,
    kOutOfMemory,
    kIsolateSpawn,
    kAssertion,
    kType,
    kAbstractClassInstantiation,
    kCyclicInitializationError,
    kCompileTimeError,
    kLateFieldAssignedDuringInitialization,
    kLateFieldNotInitialized,
  };

Member Function Documentation

Create()

ObjectPtr dart::Exceptions::Create ( ExceptionType  type, const Array &  arguments  )

static

Definition at line 1132 of file exceptions.cc.

                                                                       {
  Library& library = Library::Handle();
  const String* class_name = nullptr;
  const String* constructor_name = &Symbols::Dot();
  switch (type) {
    case kNone:
    case kStackOverflow:
    case kOutOfMemory:
      UNREACHABLE();
      break;
    case kRange:
      library = Library::CoreLibrary();
      class_name = &Symbols::RangeError();
      constructor_name = &Symbols::DotRange();
      break;
    case kRangeMsg:
      library = Library::CoreLibrary();
      class_name = &Symbols::RangeError();
      constructor_name = &Symbols::Dot();
      break;
    case kArgument:
      library = Library::CoreLibrary();
      class_name = &Symbols::ArgumentError();
      break;
    case kArgumentValue:
      library = Library::CoreLibrary();
      class_name = &Symbols::ArgumentError();
      constructor_name = &Symbols::DotValue();
      break;
    case kState:
      library = Library::CoreLibrary();
      class_name = &Symbols::StateError();
      break;
    case kIntegerDivisionByZeroException:
      library = Library::CoreLibrary();
      class_name = &Symbols::IntegerDivisionByZeroException();
      break;
    case kNoSuchMethod:
      library = Library::CoreLibrary();
      class_name = &Symbols::NoSuchMethodError();
      constructor_name = &Symbols::DotWithType();
      break;
    case kFormat:
      library = Library::CoreLibrary();
      class_name = &Symbols::FormatException();
      break;
    case kUnsupported:
      library = Library::CoreLibrary();
      class_name = &Symbols::UnsupportedError();
      break;
    case kIsolateSpawn:
      library = Library::IsolateLibrary();
      class_name = &Symbols::IsolateSpawnException();
      break;
    case kAssertion:
      library = Library::CoreLibrary();
      class_name = &Symbols::AssertionError();
      constructor_name = &Symbols::DotCreate();
      break;
    case kType:
      library = Library::CoreLibrary();
      class_name = &Symbols::TypeError();
      constructor_name = &Symbols::DotCreate();
      break;
    case kAbstractClassInstantiation:
#if defined(DART_PRECOMPILED_RUNTIME)
      UNREACHABLE();
#else
      library = Library::MirrorsLibrary();
      class_name = &Symbols::AbstractClassInstantiationError();
      constructor_name = &Symbols::DotCreate();
      break;
#endif
    case kCyclicInitializationError:
      library = Library::CoreLibrary();
      class_name = &Symbols::_CyclicInitializationError();
      break;
    case kCompileTimeError:
      library = Library::CoreLibrary();
      class_name = &Symbols::_CompileTimeError();
      break;
    case kLateFieldAssignedDuringInitialization:
      library = Library::InternalLibrary();
      class_name = &Symbols::LateError();
      constructor_name = &Symbols::DotFieldADI();
      break;
    case kLateFieldNotInitialized:
      library = Library::InternalLibrary();
      class_name = &Symbols::LateError();
      constructor_name = &Symbols::DotFieldNI();
      break;
  }
 
  return DartLibraryCalls::InstanceCreate(library, *class_name,
                                          *constructor_name, arguments);
}

CreateAndThrowTypeError()

void dart::Exceptions::CreateAndThrowTypeError ( TokenPosition  location, const AbstractType &  src_type, const AbstractType &  dst_type, const String &  dst_name  )

static

Definition at line 896 of file exceptions.cc.

                                                                 {
  ASSERT(!dst_name.IsNull());  // Pass Symbols::Empty() instead.
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Array& args = Array::Handle(zone, Array::New(4));
 
  ExceptionType exception_type = kType;
 
  DartFrameIterator iterator(thread,
                             StackFrameIterator::kNoCrossThreadIteration);
  const Script& script = Script::Handle(zone, GetCallerScript(&iterator));
  const String& url = String::Handle(
      zone, script.IsNull() ? Symbols::OptimizedOut().ptr() : script.url());
  intptr_t line = -1;
  intptr_t column = -1;
  if (!script.IsNull()) {
    script.GetTokenLocation(location, &line, &column);
  }
  // Initialize '_url', '_line', and '_column' arguments.
  args.SetAt(0, url);
  args.SetAt(1, Smi::Handle(zone, Smi::New(line)));
  args.SetAt(2, Smi::Handle(zone, Smi::New(column)));
 
  // Construct '_errorMsg'.
  const GrowableObjectArray& pieces =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New(20));
 
  if (!dst_type.IsNull()) {
    // Describe the type error.
    if (!src_type.IsNull()) {
      pieces.Add(Symbols::TypeQuote());
      pieces.Add(String::Handle(zone, src_type.UserVisibleName()));
      pieces.Add(Symbols::QuoteIsNotASubtypeOf());
    }
    pieces.Add(Symbols::TypeQuote());
    pieces.Add(String::Handle(zone, dst_type.UserVisibleName()));
    pieces.Add(Symbols::SingleQuote());
    if (dst_name.Length() > 0) {
      if (dst_name.ptr() == Symbols::InTypeCast().ptr()) {
        pieces.Add(dst_name);
      } else {
        pieces.Add(Symbols::SpaceOfSpace());
        pieces.Add(Symbols::SingleQuote());
        pieces.Add(dst_name);
        pieces.Add(Symbols::SingleQuote());
      }
    }
    // Print ambiguous URIs of src and dst types.
    URIs uris(zone, 12);
    if (!src_type.IsNull()) {
      src_type.EnumerateURIs(&uris);
    }
    if (!dst_type.IsDynamicType() && !dst_type.IsVoidType() &&
        !dst_type.IsNeverType()) {
      dst_type.EnumerateURIs(&uris);
    }
    const String& formatted_uris =
        String::Handle(zone, AbstractType::PrintURIs(&uris));
    if (formatted_uris.Length() > 0) {
      pieces.Add(Symbols::SpaceWhereNewLine());
      pieces.Add(formatted_uris);
    }
  }
  const Array& arr = Array::Handle(zone, Array::MakeFixedLength(pieces));
  const String& error_msg = String::Handle(zone, String::ConcatAll(arr));
  args.SetAt(3, error_msg);
 
  // Type errors in the core library may be difficult to diagnose.
  // Print type error information before throwing the error when debugging.
  if (FLAG_print_stacktrace_at_throw) {
    THR_Print("'%s': Failed type check: line %" Pd " pos %" Pd ": ",
              String::Handle(zone, script.url()).ToCString(), line, column);
    THR_Print("%s\n", error_msg.ToCString());
  }
 
  // Throw TypeError instance.
  Exceptions::ThrowByType(exception_type, args);
  UNREACHABLE();
}

CreateUnhandledException()

UnhandledExceptionPtr dart::Exceptions::CreateUnhandledException ( Zone *  zone, ExceptionType  type, const char *  msg  )

static

Definition at line 1229 of file exceptions.cc.

                                                                            {
  const String& error_str = String::Handle(zone, String::New(msg));
  const Array& args = Array::Handle(zone, Array::New(1));
  args.SetAt(0, error_str);
 
  Object& result = Object::Handle(zone, Exceptions::Create(type, args));
  const StackTrace& stacktrace = StackTrace::Handle(zone);
  return UnhandledException::New(Instance::Cast(result), stacktrace);
}

CurrentStackTrace()

StackTracePtr dart::Exceptions::CurrentStackTrace ( )

static

Definition at line 726 of file exceptions.cc.

                                            {
  return GetStackTraceForException();
}

GetCallerScript()

ScriptPtr dart::Exceptions::GetCallerScript ( DartFrameIterator *  iterator )

static

Definition at line 867 of file exceptions.cc.

                                                                 {
  StackFrame* caller_frame = iterator->NextFrame();
  ASSERT(caller_frame != nullptr && caller_frame->IsDartFrame());
  const Function& caller = Function::Handle(caller_frame->LookupDartFunction());
#if defined(DART_PRECOMPILED_RUNTIME)
  if (caller.IsNull()) return Script::null();
#else
  ASSERT(!caller.IsNull());
#endif
  return caller.script();
}

JumpToFrame()

NO_SANITIZE_SAFE_STACK void dart::Exceptions::JumpToFrame ( Thread *  thread, uword  program_counter, uword  stack_pointer, uword  frame_pointer, bool  clear_deopt_at_target  )

static

Definition at line 631 of file exceptions.cc.

                                                        {
  ASSERT(thread->execution_state() == Thread::kThreadInVM);
  const uword fp_for_clearing =
      (clear_deopt_at_target ? frame_pointer + 1 : frame_pointer);
  ClearLazyDeopts(thread, fp_for_clearing);
 
#if defined(USING_SIMULATOR)
  // Unwinding of the C++ frames and destroying of their stack resources is done
  // by the simulator, because the target stack_pointer is a simulated stack
  // pointer and not the C++ stack pointer.
 
  // Continue simulating at the given pc in the given frame after setting up the
  // exception object in the kExceptionObjectReg register and the stacktrace
  // object (may be raw null) in the kStackTraceObjectReg register.
 
  Simulator::Current()->JumpToFrame(program_counter, stack_pointer,
                                    frame_pointer, thread);
#else
 
  // Prepare for unwinding frames by destroying all the stack resources
  // in the previous frames.
  StackResource::Unwind(thread);
 
  // Unpoison the stack before we tear it down in the generated stub code.
  uword current_sp = OSThread::GetCurrentStackPointer() - 1024;
  ASAN_UNPOISON(reinterpret_cast<void*>(current_sp),
                stack_pointer - current_sp);
 
  // We are jumping over C++ frames, so we have to set the safestack pointer
  // back to what it was when we entered the runtime from Dart code.
#if defined(USING_SAFE_STACK)
  const uword saved_ssp = thread->saved_safestack_limit();
  OSThread::SetCurrentSafestackPointer(saved_ssp);
#endif
 
#if defined(USING_SHADOW_CALL_STACK)
  // The shadow call stack register will be restored by the JumpToFrame stub.
#endif
 
#if defined(USING_THREAD_SANITIZER)
  if (thread->exit_through_ffi() == Thread::kExitThroughRuntimeCall) {
    auto tsan_utils = thread->tsan_utils();
    tsan_utils->exception_pc = program_counter;
    tsan_utils->exception_sp = stack_pointer;
    tsan_utils->exception_fp = frame_pointer;
    longjmp(*(tsan_utils->setjmp_buffer), 1);
  }
#endif  // defined(USING_THREAD_SANITIZER)
 
  // Call a stub to set up the exception object in kExceptionObjectReg,
  // to set up the stacktrace object in kStackTraceObjectReg, and to
  // continue execution at the given pc in the given frame.
  typedef void (*ExcpHandler)(uword, uword, uword, Thread*);
  ExcpHandler func =
      reinterpret_cast<ExcpHandler>(StubCode::JumpToFrame().EntryPoint());
 
  if (thread->is_unwind_in_progress()) {
    thread->SetUnwindErrorInProgress(true);
  }
  func(program_counter, stack_pointer, frame_pointer, thread);
 
#endif
  UNREACHABLE();
}

NewInstance()

InstancePtr dart::Exceptions::NewInstance ( const char *  class_name )

static

Definition at line 882 of file exceptions.cc.

                                                          {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const String& cls_name =
      String::Handle(zone, Symbols::New(thread, class_name));
  const Library& core_lib = Library::Handle(Library::CoreLibrary());
  // No ambiguity error expected: passing nullptr.
  Class& cls = Class::Handle(core_lib.LookupClass(cls_name));
  ASSERT(!cls.IsNull());
  // There are no parameterized error types, so no need to set type arguments.
  return Instance::New(cls);
}

PropagateError()

void dart::Exceptions::PropagateError ( const Error &  error )

static

Definition at line 1003 of file exceptions.cc.

                                                  {
  ASSERT(!error.IsNull());
  Thread* thread = Thread::Current();
  // SuspendLongJumpScope during Dart entry ensures that if a longjmp base is
  // available, it is the innermost error handler. If one is available, so
  // should jump there instead.
  RELEASE_ASSERT(thread->long_jump_base() == nullptr);
  Zone* zone = thread->zone();
  if (error.IsUnhandledException()) {
    // If the error object represents an unhandled exception, then
    // rethrow the exception in the normal fashion.
    const UnhandledException& uhe = UnhandledException::Cast(error);
    const Instance& exc = Instance::Handle(zone, uhe.exception());
    const Instance& stk = Instance::Handle(zone, uhe.stacktrace());
    Exceptions::ReThrow(thread, exc, stk);
  } else {
    // Return to the invocation stub and return this error object.  The
    // C++ code which invoked this dart sequence can check and do the
    // appropriate thing.
    uword handler_pc = 0;
    uword handler_sp = 0;
    uword handler_fp = 0;
    FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
    JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp, error,
                           StackTrace::Handle(zone));  // Null stacktrace.
  }
  UNREACHABLE();
}

PropagateToEntry()

void dart::Exceptions::PropagateToEntry ( const Error &  error )

static

Definition at line 1032 of file exceptions.cc.

                                                    {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  ASSERT(thread->top_exit_frame_info() != 0);
  Instance& stacktrace = Instance::Handle(zone);
  if (error.IsUnhandledException()) {
    const UnhandledException& uhe = UnhandledException::Cast(error);
    stacktrace = uhe.stacktrace();
  } else {
    stacktrace = Exceptions::CurrentStackTrace();
  }
  uword handler_pc = 0;
  uword handler_sp = 0;
  uword handler_fp = 0;
  FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
  JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp, error,
                         stacktrace);
  UNREACHABLE();
}

ReThrow()

void dart::Exceptions::ReThrow ( Thread *  thread, const Instance &  exception, const Instance &  stacktrace, bool  bypass_debugger = false  )

static

Definition at line 986 of file exceptions.cc.

                                                 {
  // Null object is a valid exception object.
  ThrowExceptionHelper(thread, exception, stacktrace, /*is_rethrow=*/true,
                       bypass_debugger);
}

Throw()

void dart::Exceptions::Throw ( Thread *  thread, const Instance &  exception  )

static

Definition at line 979 of file exceptions.cc.

                                                                {
  // Null object is a valid exception object.
  ThrowExceptionHelper(thread, exception, StackTrace::Handle(thread->zone()),
                       /*is_rethrow=*/false,
                       /*bypass_debugger=*/false);
}

ThrowArgumentError()

void dart::Exceptions::ThrowArgumentError ( const Instance &  arg )

static

Definition at line 1082 of file exceptions.cc.

                                                       {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, arg);
  Exceptions::ThrowByType(Exceptions::kArgument, args);
}

ThrowByType()

void dart::Exceptions::ThrowByType ( ExceptionType  type, const Array &  arguments  )

static

Definition at line 1052 of file exceptions.cc.

                                                                       {
  Thread* thread = Thread::Current();
  const Object& result =
      Object::Handle(thread->zone(), Create(type, arguments));
  if (result.IsError()) {
    // We got an error while constructing the exception object.
    // Propagate the error instead of throwing the exception.
    PropagateError(Error::Cast(result));
  } else {
    ASSERT(result.IsInstance());
    Throw(thread, Instance::Cast(result));
  }
}

ThrowCompileTimeError()

void dart::Exceptions::ThrowCompileTimeError ( const LanguageError &  error )

static

Definition at line 1112 of file exceptions.cc.

                                                                 {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, String::Handle(error.FormatMessage()));
  Exceptions::ThrowByType(Exceptions::kCompileTimeError, args);
}

ThrowLateFieldAssignedDuringInitialization()

void dart::Exceptions::ThrowLateFieldAssignedDuringInitialization ( const String &  name )

static

Definition at line 1124 of file exceptions.cc.

                        {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, name);
  Exceptions::ThrowByType(Exceptions::kLateFieldAssignedDuringInitialization,
                          args);
}

ThrowLateFieldNotInitialized()

void dart::Exceptions::ThrowLateFieldNotInitialized ( const String &  name )

static

Definition at line 1118 of file exceptions.cc.

                                                                {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, name);
  Exceptions::ThrowByType(Exceptions::kLateFieldNotInitialized, args);
}

ThrowOOM()

void dart::Exceptions::ThrowOOM ( )

static

Definition at line 1066 of file exceptions.cc.

                          {
  auto thread = Thread::Current();
  auto isolate_group = thread->isolate_group();
  const Instance& oom = Instance::Handle(
      thread->zone(), isolate_group->object_store()->out_of_memory());
  Throw(thread, oom);
}

ThrowRangeError()

void dart::Exceptions::ThrowRangeError ( const char *  argument_name, const Integer &  argument_value, intptr_t  expected_from, intptr_t  expected_to  )

static

Definition at line 1094 of file exceptions.cc.

                                                       {
  const Array& args = Array::Handle(Array::New(4));
  args.SetAt(0, argument_value);
  args.SetAt(1, Integer::Handle(Integer::New(expected_from)));
  args.SetAt(2, Integer::Handle(Integer::New(expected_to)));
  args.SetAt(3, String::Handle(String::New(argument_name)));
  Exceptions::ThrowByType(Exceptions::kRange, args);
}

ThrowStackOverflow()

void dart::Exceptions::ThrowStackOverflow ( )

static

Definition at line 1074 of file exceptions.cc.

                                    {
  auto thread = Thread::Current();
  auto isolate_group = thread->isolate_group();
  const Instance& stack_overflow = Instance::Handle(
      thread->zone(), isolate_group->object_store()->stack_overflow());
  Throw(thread, stack_overflow);
}

ThrowStateError()

void dart::Exceptions::ThrowStateError ( const Instance &  arg )

static

Definition at line 1088 of file exceptions.cc.

                                                    {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, arg);
  Exceptions::ThrowByType(Exceptions::kState, args);
}

ThrowUnsupportedError()

void dart::Exceptions::ThrowUnsupportedError ( const char *  msg )

static

Definition at line 1106 of file exceptions.cc.

                                                      {
  const Array& args = Array::Handle(Array::New(1));
  args.SetAt(0, String::Handle(String::New(msg)));
  Exceptions::ThrowByType(Exceptions::kUnsupported, args);
}

ThrowWithStackTrace()

void dart::Exceptions::ThrowWithStackTrace ( Thread *  thread, const Instance &  exception, const Instance &  stacktrace  )

static

Definition at line 995 of file exceptions.cc.

                                                                 {
  // Null object is a valid exception object.
  ThrowExceptionHelper(thread, exception, stacktrace, /*is_rethrow=*/false,
                       /*bypass_debugger=*/false);
}

---

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

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