VM: Better handling of OOM errors in the background compiler

runtime/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 "platform/address_sanitizer.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/log.h"
+#include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_stacktrace_at_throw, false,
@@ skipping 115 matching lines @@
 // exception handler. Once found, set the pc, sp and fp so that execution
 // can continue in that frame. Sets 'needs_stacktrace' if there is no
 // cath-all handler or if a stack-trace is specified in the catch.
 static bool FindExceptionHandler(Thread* thread,
                                  uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
                                  bool* needs_stacktrace) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
-  ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
+  if (frame == NULL) return false;  // No Dart frame.
   bool handler_pc_set = false;
   *needs_stacktrace = false;
   bool is_catch_all = false;
   uword temp_handler_pc = kUwordMax;
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
       if (frame->FindExceptionHandler(thread,
                                       &temp_handler_pc,
                                       needs_stacktrace,
                                       &is_catch_all)) {
@@ skipping 160 matching lines @@
   bool handler_exists = false;
   bool handler_needs_stacktrace = false;
   if (use_preallocated_stacktrace) {
     stacktrace ^= isolate->object_store()->preallocated_stack_trace();
     PreallocatedStacktraceBuilder frame_builder(stacktrace);
     handler_exists = FindExceptionHandler(thread,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
+    if (handler_pc == 0) {
+      // No Dart frame.
+      ASSERT(!thread->IsMutatorThread());
+      ASSERT(incoming_exception.raw() ==
+             isolate->object_store()->out_of_memory());
+      const UnhandledException& error = UnhandledException::Handle(
+          zone, isolate->object_store()->preallocated_unhandled_exception());
+      thread->long_jump_base()->Jump(1, error);
+      UNREACHABLE();
+    }
     if (handler_needs_stacktrace) {
       BuildStackTrace(&frame_builder);
     }
   } else {
     // Get stacktrace field of class Error. This is needed to determine whether
     // we have a subclass of Error which carries around its stack trace.
     const Field& stacktrace_field =
         Field::Handle(zone, LookupStacktraceField(exception));
 
     // Find the exception handler and determine if the handler needs a
@@ skipping 376 matching lines @@
   }
 
   return DartLibraryCalls::InstanceCreate(library,
                                           *class_name,
                                           *constructor_name,
                                           arguments);
 }
 
 
 }  // namespace dart