Return an unhandled exception error on an OOM or other errors while

vm/exceptions.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/exceptions.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
@@ skipping 15 matching lines @@
 // exception handler. Once found, set the pc, sp and fp so that execution
 // can continue in that frame.
 static bool FindExceptionHandler(uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
                                  const GrowableObjectArray& func_list,
                                  const GrowableObjectArray& code_list,
                                  const GrowableObjectArray& pc_offset_list) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
-  if (frame == NULL) {
-    // We have no dart invocation frames and hence cannot find a handler
-    // to return to.
-    return false;
-  }
+  ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Function& func = Function::Handle();
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
       func = frame->LookupDartFunction();
       code = frame->LookupDartCode();
       offset = Smi::New(frame->pc() - code.EntryPoint());
       func_list.Add(func);
       code_list.Add(code);
@@ skipping 104 matching lines @@
   const GrowableObjectArray& code_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   const GrowableObjectArray& pc_offset_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   bool handler_exists = FindExceptionHandler(&handler_pc,
                                              &handler_sp,
                                              &handler_fp,
                                              func_list,
                                              code_list,
                                              pc_offset_list);
-  if (handler_pc == 0) {
-    // There are no dart invocation frames on the stack so we do not
-    // have a caller to return to.
-    ASSERT(!handler_exists);
-    if (Isolate::UnhandledExceptionCallback() != NULL) {
-      // Notify embedder that an unhandled exception occurred.
-      Dart_EnterScope();
-      Dart_Handle error_handle = Api::NewHandle(Isolate::Current(),
-                                                incoming_exception.raw());
-      (Isolate::UnhandledExceptionCallback())(error_handle);
-      Dart_ExitScope();
-    } else {
-      OS::PrintErr("Exception '%s' thrown:\n", exception.ToCString());
-      OS::PrintErr("Shutting down the isolate\n");
-    }
-    Dart_ShutdownIsolate();
-  }
+  // We expect to find a handler_pc, if the exception is unhandled
+  // then we expect to at least have the dart entry frame on the
+  // stack as Exceptions::Throw should happen only after a dart
+  // invocation has been done.
+  ASSERT(handler_pc != 0);
+
   // TODO(5411263): At some point we can optimize by figuring out if a
   // stack trace is needed based on whether the catch code specifies a
   // stack trace object or there is a rethrow in the catch clause.
   Stacktrace& stacktrace = Stacktrace::Handle();
   if (pc_offset_list.Length() != 0) {
     if (existing_stacktrace.IsNull()) {
       stacktrace = Stacktrace::New(func_list, code_list, pc_offset_list);
     } else {
       stacktrace ^= existing_stacktrace.raw();
       stacktrace.Append(func_list, code_list, pc_offset_list);
@@ skipping 253 matching lines @@
     case kIsolateSpawn:
       library = Library::IsolateLibrary();
       class_name = Symbols::New("IsolateSpawnException");
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library, class_name, arguments);
 }
 
 }  // namespace dart