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

vm/snapshot.cc

 // Copyright (c) 2012, 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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 139 matching lines @@
       isolate_(isolate),
       cls_(Class::Handle()),
       obj_(Object::Handle()),
       str_(String::Handle()),
       library_(Library::Handle()),
       type_(AbstractType::Handle()),
       type_arguments_(AbstractTypeArguments::Handle()),
       tokens_(Array::Handle()),
       stream_(TokenStream::Handle()),
       data_(ExternalUint8Array::Handle()),
+      error_(UnhandledException::Handle()),
       backward_references_((kind == Snapshot::kFull) ?
                            kNumInitialReferencesInFullSnapshot :
                            kNumInitialReferences) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
-  Object& obj = Object::Handle(ReadObjectImpl());
-  for (intptr_t i = 0; i < backward_references_.length(); i++) {
-    if (!backward_references_[i]->is_deserialized()) {
-      ReadObjectImpl();
-      backward_references_[i]->set_state(kIsDeserialized);
+  // Setup for long jump in case there is an exception while reading.
+  LongJump* base = isolate()->long_jump_base();
+  LongJump jump;
+  isolate()->set_long_jump_base(&jump);
+  const Instance& null_object = Instance::Handle();
+  *ErrorHandle() = UnhandledException::New(null_object, null_object);
+  if (setjmp(*jump.Set()) == 0) {
+    Object& obj = Object::Handle(ReadObjectImpl());
+    for (intptr_t i = 0; i < backward_references_.length(); i++) {
+      if (!backward_references_[i]->is_deserialized()) {
+        ReadObjectImpl();
+        backward_references_[i]->set_state(kIsDeserialized);
+      }
     }
+    isolate()->set_long_jump_base(base);
+    return obj.raw();
+  } else {
+    // An error occurred while reading, return the error object.
+    const Error& err = Error::Handle(isolate()->object_store()->sticky_error());
+    isolate()->object_store()->clear_sticky_error();
+    isolate()->set_long_jump_base(base);
+    return err.raw();
   }
-  return obj.raw();
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
   ASSERT(kind_ != Snapshot::kFull);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   Class& cls = Class::ZoneHandle(isolate(), Class::null());
   cls = LookupInternalClass(class_header);
@@ skipping 423 matching lines @@
 RawObject* SnapshotReader::AllocateUninitialized(const Class& cls,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Heap* heap = isolate()->heap();
 
   uword address = heap->TryAllocate(size, Heap::kOld);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
+    // We do a longjmp at this point to unwind out of the entire
+    // read part and return the error object back.
     const Instance& exception =
         Instance::Handle(object_store()->out_of_memory());
-    Exceptions::Throw(exception);
-    UNREACHABLE();
+    ErrorHandle()->set_exception(exception);
+    Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
   }
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   uword tags = 0;
   intptr_t index = cls.id();
   ASSERT(index != kIllegalCid);
   tags = RawObject::ClassIdTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
@@ skipping 665 matching lines @@
     UnmarkAll();
     isolate->set_long_jump_base(base);
   } else {
     isolate->set_long_jump_base(base);
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart