Avoid allocating an exception object in the snapshot reader.

runtime/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/class_finalizer.h"
@@ skipping 149 matching lines @@
       stream_(TokenStream::Handle(isolate)),
       data_(ExternalTypedData::Handle(isolate)),
       error_(UnhandledException::Handle(isolate)),
       backward_references_((kind == Snapshot::kFull) ?
                            kNumInitialReferencesInFullSnapshot :
                            kNumInitialReferences) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
-  const Instance& null_object = Instance::Handle();
-  *ErrorHandle() = UnhandledException::New(null_object, null_object);
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   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);
       }
     }
@@ skipping 487 matching lines @@
 RawApiError* SnapshotReader::NewApiError() {
   ALLOC_NEW_OBJECT(ApiError, Object::api_error_class());
 }
 
 
 RawLanguageError* SnapshotReader::NewLanguageError() {
   ALLOC_NEW_OBJECT(LanguageError, Object::language_error_class());
 }
 
 
+RawUnhandledException* SnapshotReader::NewUnhandledException() {
+  ALLOC_NEW_OBJECT(UnhandledException, Object::unhandled_exception_class());
+}
+
+
 RawObject* SnapshotReader::NewInteger(int64_t value) {
   ASSERT((value & kSmiTagMask) == kSmiTag);
   value = value >> kSmiTagShift;
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
   if (kind_ == Snapshot::kFull) {
     return NewMint(value);
   }
   return Mint::NewCanonical(value);
@@ skipping 28 matching lines @@
   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());
-    ErrorHandle()->set_exception(exception);
-    Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
+    const UnhandledException& error = UnhandledException::Handle(
+        object_store()->preallocated_unhandled_exception());
+    Isolate::Current()->long_jump_base()->Jump(1, error);
   }
 #if defined(DEBUG)
   // Zap the uninitialized memory area.
   uword current = address;
   uword end = address + size;
   while (current < end) {
     *reinterpret_cast<intptr_t*>(current) = kZapUninitializedWord;
     current += kWordSize;
   }
 #endif  // defined(DBEUG)
@@ skipping 864 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart