VM: Better handling of OOM errors in the background compiler

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, 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/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 943 matching lines @@
             inliner_->NextInlineId(callee_graph->function(),
                                    call_data->call->token_pos(),
                                    call_data->caller_inlining_id_));
         TRACE_INLINING(THR_Print("     Success\n"));
         PRINT_INLINING_TREE(NULL,
             &call_data->caller, &function, call);
         return true;
       } else {
         error = thread()->sticky_error();
         thread()->clear_sticky_error();
-        ASSERT(error.IsLanguageError());
 
-        if (LanguageError::Cast(error).kind() == Report::kBailout) {
+        if (error.IsLanguageError() &&
+            (LanguageError::Cast(error).kind() == Report::kBailout)) {
           if (error.raw() == Object::background_compilation_error().raw()) {
              // Fall through to exit the compilation, and retry it later.
           } else {
             thread()->set_deopt_id(prev_deopt_id);
             TRACE_INLINING(THR_Print("     Bailout: %s\n",
                                      error.ToErrorCString()));
             PRINT_INLINING_TREE("Bailout",
                 &call_data->caller, &function, call);
             return false;
           }
         } else {
           // Fall through to exit long jump scope.
-          ASSERT(FLAG_precompiled_mode);
         }
       }
     }
 
     // Propagate a compile-time error. In precompilation we attempt to
     // inline functions that have never been compiled before; when JITing we
-    // should only see compile-time errors in unoptimized compilation.
+    // should only see language errors in unoptimized compilation.
+    // Otherwise, there can be an out-of-memory error (unhandled exception).
     // In background compilation we may abort compilation as the state
     // changes while compiling. Propagate that 'error' and retry compilation
     // later.
-    ASSERT(FLAG_precompiled_mode || Compiler::IsBackgroundCompilation());
+    ASSERT(FLAG_precompiled_mode ||
+           Compiler::IsBackgroundCompilation() ||
+           error.IsUnhandledException());
     Thread::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
     return false;
   }
 
   void PrintInlinedInfo(const Function& top) {
     if (inlined_info_.length() > 0) {
       THR_Print("Inlining into: '%s' growth: %f (%" Pd " -> %" Pd ")\n",
           top.ToFullyQualifiedCString(),
           GrowthFactor(),
@@ skipping 2781 matching lines @@
       return true;
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart