VM: Re-format to use at most one newline between functions

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/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 13 matching lines @@
 
 // We currently only expect the Dart mutator to read snapshots.
 #define ASSERT_NO_SAFEPOINT_SCOPE()                                            \
   isolate()->AssertCurrentThreadIsMutator();                                   \
   ASSERT(thread()->no_safepoint_scope_depth() != 0)
 
 namespace dart {
 
 static const int kNumInitialReferences = 32;
 
-
 static bool IsSingletonClassId(intptr_t class_id) {
   // Check if this is a singleton object class which is shared by all isolates.
   return ((class_id >= kClassCid && class_id <= kUnwindErrorCid) ||
           (class_id >= kNullCid && class_id <= kVoidCid));
 }
 
-
 static bool IsObjectStoreClassId(intptr_t class_id) {
   // Check if this is a class which is stored in the object store.
   return (class_id == kObjectCid ||
           (class_id >= kInstanceCid && class_id <= kUserTagCid) ||
           class_id == kArrayCid || class_id == kImmutableArrayCid ||
           RawObject::IsStringClassId(class_id) ||
           RawObject::IsTypedDataClassId(class_id) ||
           RawObject::IsExternalTypedDataClassId(class_id) ||
           class_id == kNullCid);
 }
 
-
 static bool IsObjectStoreTypeId(intptr_t index) {
   // Check if this is a type which is stored in the object store.
   return (index >= kObjectType && index <= kArrayType);
 }
 
-
 static bool IsSplitClassId(intptr_t class_id) {
   // Return whether this class is serialized in two steps: first a reference,
   // with sufficient information to allocate a correctly sized object, and then
   // later inline with complete contents.
   return class_id >= kNumPredefinedCids || class_id == kArrayCid ||
          class_id == kImmutableArrayCid || class_id == kObjectPoolCid ||
          RawObject::IsImplicitFieldClassId(class_id);
 }
 
-
 static intptr_t ClassIdFromObjectId(intptr_t object_id) {
   ASSERT(object_id > kClassIdsOffset);
   intptr_t class_id = (object_id - kClassIdsOffset);
   return class_id;
 }
 
-
 static intptr_t ObjectIdFromClassId(intptr_t class_id) {
   ASSERT((class_id > kIllegalCid) && (class_id < kNumPredefinedCids));
   ASSERT(!(RawObject::IsImplicitFieldClassId(class_id)));
   return (class_id + kClassIdsOffset);
 }
 
-
 static RawType* GetType(ObjectStore* object_store, intptr_t index) {
   switch (index) {
     case kObjectType:
       return object_store->object_type();
     case kNullType:
       return object_store->null_type();
     case kFunctionType:
       return object_store->function_type();
     case kNumberType:
       return object_store->number_type();
@@ skipping 11 matching lines @@
       return object_store->string_type();
     case kArrayType:
       return object_store->array_type();
     default:
       break;
   }
   UNREACHABLE();
   return Type::null();
 }
 
-
 static intptr_t GetTypeIndex(ObjectStore* object_store,
                              const RawType* raw_type) {
   ASSERT(raw_type->IsHeapObject());
   if (raw_type == object_store->object_type()) {
     return kObjectType;
   } else if (raw_type == object_store->null_type()) {
     return kNullType;
   } else if (raw_type == object_store->function_type()) {
     return kFunctionType;
   } else if (raw_type == object_store->number_type()) {
     return kNumberType;
   } else if (raw_type == object_store->smi_type()) {
     return kSmiType;
   } else if (raw_type == object_store->mint_type()) {
     return kMintType;
   } else if (raw_type == object_store->double_type()) {
     return kDoubleType;
   } else if (raw_type == object_store->int_type()) {
     return kIntType;
   } else if (raw_type == object_store->bool_type()) {
     return kBoolType;
   } else if (raw_type == object_store->string_type()) {
     return kStringType;
   } else if (raw_type == object_store->array_type()) {
     return kArrayType;
   }
   return kInvalidIndex;
 }
 
-
 const char* Snapshot::KindToCString(Kind kind) {
   switch (kind) {
     case kFull:
       return "full";
     case kScript:
       return "script";
     case kMessage:
       return "message";
     case kFullJIT:
       return "full-jit";
     case kFullAOT:
       return "full-aot";
     case kNone:
       return "none";
     case kInvalid:
     default:
       return "invalid";
   }
 }
 
-
 // TODO(5411462): Temporary setup of snapshot for testing purposes,
 // the actual creation of a snapshot maybe done differently.
 const Snapshot* Snapshot::SetupFromBuffer(const void* raw_memory) {
   ASSERT(raw_memory != NULL);
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int64_t)) == kind_offset());
   ASSERT((kHeapObjectTag & kInlined));
   const Snapshot* snapshot = reinterpret_cast<const Snapshot*>(raw_memory);
   // If the raw length is negative or greater than what the local machine can
   // handle, then signal an error.
   int64_t snapshot_length = ReadUnaligned(&snapshot->unaligned_length_);
   if ((snapshot_length < 0) || (snapshot_length > kIntptrMax)) {
     return NULL;
   }
   return snapshot;
 }
 
-
 RawSmi* BaseReader::ReadAsSmi() {
   intptr_t value = Read<int32_t>();
   ASSERT((value & kSmiTagMask) == kSmiTag);
   return reinterpret_cast<RawSmi*>(value);
 }
 
-
 intptr_t BaseReader::ReadSmiValue() {
   return Smi::Value(ReadAsSmi());
 }
 
-
 SnapshotReader::SnapshotReader(const uint8_t* buffer,
                                intptr_t size,
                                Snapshot::Kind kind,
                                ZoneGrowableArray<BackRefNode>* backward_refs,
                                Thread* thread)
     : BaseReader(buffer, size),
       kind_(kind),
       thread_(thread),
       zone_(thread->zone()),
       heap_(isolate()->heap()),
@@ skipping 12 matching lines @@
       data_(ExternalTypedData::Handle(zone_)),
       typed_data_(TypedData::Handle(zone_)),
       function_(Function::Handle(zone_)),
       error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (Snapshot::IsFull(kind))
               ? Object::vm_isolate_snapshot_object_table().Length()
               : 0),
       backward_references_(backward_refs) {}
 
-
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     PassiveObject& obj =
         PassiveObject::Handle(zone(), ReadObjectImpl(kAsInlinedObject));
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
     if (backward_references_->length() > 0) {
       ProcessDeferredCanonicalizations();
       if (kind() == Snapshot::kScript) {
         FixSubclassesAndImplementors();
       }
       return (*backward_references_)[0].reference()->raw();
     } else {
       return obj.raw();
     }
   } else {
     // An error occurred while reading, return the error object.
     const Error& err = Error::Handle(thread()->sticky_error());
     thread()->clear_sticky_error();
     return err.raw();
   }
 }
 
-
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
   ASSERT(!Snapshot::IsFull(kind_));
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<int32_t>();
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   ASSERT(!IsVMIsolateObject(class_header) ||
          !IsSingletonClassId(GetVMIsolateObjectId(class_header)));
   ASSERT((SerializedHeaderTag::decode(class_header) != kObjectId) ||
          !IsObjectStoreClassId(SerializedHeaderData::decode(class_header)));
   Class& cls = Class::ZoneHandle(zone(), Class::null());
@@ skipping 10 matching lines @@
   } else {
     cls = library_.LookupClassAllowPrivate(str_);
   }
   if (cls.IsNull()) {
     SetReadException("Invalid object found in message.");
   }
   cls.EnsureIsFinalized(thread());
   return cls.raw();
 }
 
-
 RawFunction* SnapshotReader::ReadFunctionId(intptr_t object_id) {
   ASSERT(kind_ == Snapshot::kScript);
   // Read the function header information and lookup the function.
   intptr_t func_header = Read<int32_t>();
   ASSERT((func_header & kSmiTagMask) != kSmiTag);
   ASSERT(!IsVMIsolateObject(func_header) ||
          !IsSingletonClassId(GetVMIsolateObjectId(func_header)));
   ASSERT((SerializedHeaderTag::decode(func_header) != kObjectId) ||
          !IsObjectStoreClassId(SerializedHeaderData::decode(func_header)));
   Function& func = Function::ZoneHandle(zone(), Function::null());
@@ skipping 16 matching lines @@
     cls_.EnsureIsFinalized(thread());
     str_ ^= ReadObjectImpl(kAsInlinedObject);
     func ^= cls_.LookupFunctionAllowPrivate(str_);
   }
   if (func.IsNull()) {
     SetReadException("Expected a function name, but found an invalid name.");
   }
   return func.raw();
 }
 
-
 RawObject* SnapshotReader::ReadStaticImplicitClosure(intptr_t object_id,
                                                      intptr_t class_header) {
   ASSERT(!Snapshot::IsFull(kind_));
 
   // First create a function object and associate it with the specified
   // 'object_id'.
   Function& func = Function::Handle(zone(), Function::null());
   Instance& obj = Instance::ZoneHandle(zone(), Instance::null());
   AddBackRef(object_id, &obj, kIsDeserialized);
 
@@ skipping 21 matching lines @@
     SetReadException("Invalid function object found in message.");
   }
   func = func.ImplicitClosureFunction();
   ASSERT(!func.IsNull());
 
   // Return the associated implicit static closure.
   obj = func.ImplicitStaticClosure();
   return obj.raw();
 }
 
-
 intptr_t SnapshotReader::NextAvailableObjectId() const {
   return backward_references_->length() + kMaxPredefinedObjectIds +
          max_vm_isolate_object_id_;
 }
 
-
 void SnapshotReader::SetReadException(const char* msg) {
   const String& error_str = String::Handle(zone(), String::New(msg));
   const Array& args = Array::Handle(zone(), Array::New(1));
   args.SetAt(0, error_str);
   Object& result = Object::Handle(zone());
   const Library& library = Library::Handle(zone(), Library::CoreLibrary());
   result = DartLibraryCalls::InstanceCreate(library, Symbols::ArgumentError(),
                                             Symbols::Dot(), args);
   const StackTrace& stacktrace = StackTrace::Handle(zone());
   const UnhandledException& error = UnhandledException::Handle(
       zone(), UnhandledException::New(Instance::Cast(result), stacktrace));
   thread()->long_jump_base()->Jump(1, error);
 }
 
-
 RawObject* SnapshotReader::VmIsolateSnapshotObject(intptr_t index) const {
   return Object::vm_isolate_snapshot_object_table().At(index);
 }
 
-
 bool SnapshotReader::is_vm_isolate() const {
   return isolate() == Dart::vm_isolate();
 }
 
-
 RawObject* SnapshotReader::ReadObjectImpl(bool as_reference,
                                           intptr_t patch_object_id,
                                           intptr_t patch_offset) {
   int64_t header_value = Read<int64_t>();
   if ((header_value & kSmiTagMask) == kSmiTag) {
     return NewInteger(header_value);
   }
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   return ReadObjectImpl(static_cast<intptr_t>(header_value), as_reference,
                         patch_object_id, patch_offset);
 }
 
-
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value,
                                           bool as_reference,
                                           intptr_t patch_object_id,
                                           intptr_t patch_offset) {
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   }
   if (SerializedHeaderTag::decode(header_value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(header_value),
                              patch_object_id, patch_offset);
@@ skipping 48 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
   if (!read_as_reference) {
     AddPatchRecord(object_id, patch_object_id, patch_offset);
   }
   return pobj_.raw();
 }
 
-
 RawObject* SnapshotReader::ReadInstance(intptr_t object_id,
                                         intptr_t tags,
                                         bool as_reference) {
   // Object is regular dart instance.
   intptr_t instance_size = 0;
   Instance* result = NULL;
   DeserializeState state;
   if (!as_reference) {
     result = reinterpret_cast<Instance*>(GetBackRef(object_id));
     state = kIsDeserialized;
@@ skipping 49 matching lines @@
       offset += kWordSize;
     }
     if (RawObject::IsCanonical(tags)) {
       *result = result->CheckAndCanonicalize(thread(), NULL);
       ASSERT(!result->IsNull());
     }
   }
   return result->raw();
 }
 
-
 void SnapshotReader::AddBackRef(intptr_t id,
                                 Object* obj,
                                 DeserializeState state,
                                 bool defer_canonicalization) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index >= max_vm_isolate_object_id_);
   index -= max_vm_isolate_object_id_;
   ASSERT(index == backward_references_->length());
   BackRefNode node(obj, state, defer_canonicalization);
   backward_references_->Add(node);
 }
 
-
 Object* SnapshotReader::GetBackRef(intptr_t id) {
   ASSERT(id >= kMaxPredefinedObjectIds);
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index >= max_vm_isolate_object_id_);
   index -= max_vm_isolate_object_id_;
   if (index < backward_references_->length()) {
     return (*backward_references_)[index].reference();
   }
   return NULL;
 }
 
-
 class HeapLocker : public StackResource {
  public:
   HeapLocker(Thread* thread, PageSpace* page_space)
       : StackResource(thread), page_space_(page_space) {
     page_space_->AcquireDataLock();
   }
   ~HeapLocker() { page_space_->ReleaseDataLock(); }
 
  private:
   PageSpace* page_space_;
 };
 
-
 RawObject* SnapshotReader::ReadScriptSnapshot() {
   ASSERT(kind_ == Snapshot::kScript);
 
   // First read the version string, and check that it matches.
   RawApiError* error = VerifyVersionAndFeatures(Isolate::Current());
   if (error != ApiError::null()) {
     return error;
   }
 
   // The version string matches. Read the rest of the snapshot.
   obj_ = ReadObject();
   if (!obj_.IsLibrary()) {
     if (!obj_.IsError()) {
       const intptr_t kMessageBufferSize = 128;
       char message_buffer[kMessageBufferSize];
       OS::SNPrint(message_buffer, kMessageBufferSize,
                   "Invalid object %s found in script snapshot",
                   obj_.ToCString());
       const String& msg = String::Handle(String::New(message_buffer));
       obj_ = ApiError::New(msg);
     }
   }
   return obj_.raw();
 }
 
-
 RawApiError* SnapshotReader::VerifyVersionAndFeatures(Isolate* isolate) {
   // If the version string doesn't match, return an error.
   // Note: New things are allocated only if we're going to return an error.
 
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   if (PendingBytes() < version_len) {
     const intptr_t kMessageBufferSize = 128;
     char message_buffer[kMessageBufferSize];
@@ skipping 46 matching lines @@
     // This can also fail while bringing up the VM isolate, so make sure to
     // allocate the error message in old space.
     const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
     return ApiError::New(msg, Heap::kOld);
   }
   free(const_cast<char*>(expected_features));
   Advance(expected_len + 1);
   return ApiError::null();
 }
 
-
 RawObject* SnapshotReader::NewInteger(int64_t value) {
   ASSERT((value & kSmiTagMask) == kSmiTag);
   value = value >> kSmiTagShift;
   if (Smi::IsValid(value)) {
     return Smi::New(static_cast<intptr_t>(value));
   }
   return Mint::NewCanonical(value);
 }
 
-
 int32_t ImageWriter::GetTextOffsetFor(RawInstructions* instructions,
                                       RawCode* code) {
   intptr_t heap_size = instructions->Size();
   intptr_t offset = next_offset_;
   next_offset_ += heap_size;
   instructions_.Add(InstructionsData(instructions, code, offset));
   return offset;
 }
 
-
 int32_t ImageWriter::GetDataOffsetFor(RawObject* raw_object) {
   intptr_t heap_size = raw_object->Size();
   intptr_t offset = next_object_offset_;
   next_object_offset_ += heap_size;
   objects_.Add(ObjectData(raw_object));
   return offset;
 }
 
-
 void ImageWriter::Write(WriteStream* clustered_stream, bool vm) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                                            "WriteInstructions"));
 
   // Handlify collected raw pointers as building the names below
   // will allocate on the Dart heap.
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     InstructionsData& data = instructions_[i];
     data.insns_ = &Instructions::Handle(zone, data.raw_insns_);
     ASSERT(data.raw_code_ != NULL);
     data.code_ = &Code::Handle(zone, data.raw_code_);
   }
   for (intptr_t i = 0; i < objects_.length(); i++) {
     ObjectData& data = objects_[i];
     data.obj_ = &Object::Handle(zone, data.raw_obj_);
   }
 
   // Append the direct-mapped RO data objects after the clustered snapshot.
   WriteROData(clustered_stream);
 
   WriteText(clustered_stream, vm);
 }
 
-
 void ImageWriter::WriteROData(WriteStream* stream) {
   stream->Align(OS::kMaxPreferredCodeAlignment);
 
   // Heap page starts here.
 
   stream->WriteWord(next_object_offset_);  // Data length.
   COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
   stream->Align(OS::kMaxPreferredCodeAlignment);
 
   // Heap page objects start here.
@@ skipping 14 matching lines @@
 #endif
     stream->WriteWord(marked_tags);
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
          cursor < reinterpret_cast<uword*>(end); cursor++) {
       stream->WriteWord(*cursor);
     }
   }
 }
 
-
 AssemblyImageWriter::AssemblyImageWriter(uint8_t** assembly_buffer,
                                          ReAlloc alloc,
                                          intptr_t initial_size)
     : ImageWriter(),
       assembly_stream_(assembly_buffer, alloc, initial_size),
       text_size_(0),
       dwarf_(NULL) {
 #if defined(DART_PRECOMPILER)
   Zone* zone = Thread::Current()->zone();
   dwarf_ = new (zone) Dwarf(zone, &assembly_stream_);
 #endif
 }
 
-
 void AssemblyImageWriter::Finalize() {
 #ifdef DART_PRECOMPILER
   dwarf_->Write();
 #endif
 }
 
-
 static void EnsureIdentifier(char* label) {
   for (char c = *label; c != '\0'; c = *++label) {
     if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
       continue;
     }
     *label = '_';
   }
 }
 
-
 void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   Zone* zone = Thread::Current()->zone();
 
   const char* instructions_symbol =
       vm ? "_kDartVmSnapshotInstructions" : "_kDartIsolateSnapshotInstructions";
   assembly_stream_.Print(".text\n");
   assembly_stream_.Print(".globl %s\n", instructions_symbol);
 
   // Start snapshot at page boundary.
   ASSERT(VirtualMemory::PageSize() >= OS::kMaxPreferredCodeAlignment);
@@ skipping 101 matching lines @@
       vm ? "_kDartVmSnapshotData" : "_kDartIsolateSnapshotData";
   assembly_stream_.Print(".globl %s\n", data_symbol);
   assembly_stream_.Print(".balign %" Pd ", 0\n",
                          OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print("%s:\n", data_symbol);
   uword buffer = reinterpret_cast<uword>(clustered_stream->buffer());
   intptr_t length = clustered_stream->bytes_written();
   WriteByteSequence(buffer, buffer + length);
 }
 
-
 void AssemblyImageWriter::FrameUnwindPrologue() {
   // Creates DWARF's .debug_frame
   // CFI = Call frame information
   // CFA = Canonical frame address
   assembly_stream_.Print(".cfi_startproc\n");
 
 #if defined(TARGET_ARCH_X64)
   assembly_stream_.Print(".cfi_def_cfa rbp, 0\n");  // CFA is fp+0
   assembly_stream_.Print(".cfi_offset rbp, 0\n");   // saved fp is *(CFA+0)
   assembly_stream_.Print(".cfi_offset rip, 8\n");   // saved pc is *(CFA+8)
@@ skipping 19 matching lines @@
   // DW_CFA_expression          0x10
   // uleb128 register (x31)       31
   // uleb128 size of operation     2
   // DW_OP_plus_uconst          0x23
   // uleb128 addend               16
   assembly_stream_.Print(".cfi_escape 0x10, 31, 2, 0x23, 16\n");
 
 #elif defined(TARGET_ARCH_ARM)
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
   COMPILE_ASSERT(FP == R7);
-  assembly_stream_.Print(".cfi_def_cfa r7, 0\n");   // CFA is fp+j0
-  assembly_stream_.Print(".cfi_offset r7, 0\n");    // saved fp is *(CFA+0)
+  assembly_stream_.Print(".cfi_def_cfa r7, 0\n");  // CFA is fp+j0
+  assembly_stream_.Print(".cfi_offset r7, 0\n");   // saved fp is *(CFA+0)
 #else
   COMPILE_ASSERT(FP == R11);
   assembly_stream_.Print(".cfi_def_cfa r11, 0\n");  // CFA is fp+0
   assembly_stream_.Print(".cfi_offset r11, 0\n");   // saved fp is *(CFA+0)
 #endif
-  assembly_stream_.Print(".cfi_offset lr, 4\n");    // saved pc is *(CFA+4)
+  assembly_stream_.Print(".cfi_offset lr, 4\n");   // saved pc is *(CFA+4)
   // saved sp is CFA+8
   // Should be ".cfi_value_offset sp, 8", but requires gcc newer than late
   // 2016 and not supported by Android's libunwind.
   // DW_CFA_expression          0x10
   // uleb128 register (sp)        13
   // uleb128 size of operation     2
   // DW_OP_plus_uconst          0x23
   // uleb128 addend                8
   assembly_stream_.Print(".cfi_escape 0x10, 13, 2, 0x23, 8\n");
 
 // libunwind on ARM may use .ARM.exidx instead of .debug_frame
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
   COMPILE_ASSERT(FP == R7);
   assembly_stream_.Print(".fnstart\n");
   assembly_stream_.Print(".save {r7, lr}\n");
   assembly_stream_.Print(".setfp r7, sp, #0\n");
 #else
   COMPILE_ASSERT(FP == R11);
   assembly_stream_.Print(".fnstart\n");
   assembly_stream_.Print(".save {r11, lr}\n");
   assembly_stream_.Print(".setfp r11, sp, #0\n");
 #endif
 
 #endif
 }
 
-
 void AssemblyImageWriter::FrameUnwindEpilogue() {
 #if defined(TARGET_ARCH_ARM)
   assembly_stream_.Print(".fnend\n");
 #endif
   assembly_stream_.Print(".cfi_endproc\n");
 }
 
-
 void AssemblyImageWriter::WriteByteSequence(uword start, uword end) {
   for (uword* cursor = reinterpret_cast<uword*>(start);
        cursor < reinterpret_cast<uword*>(end); cursor++) {
     WriteWordLiteralText(*cursor);
   }
 }
 
-
 void BlobImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   // This header provides the gap to make the instructions snapshot look like a
   // HeapPage.
   intptr_t instructions_length = next_offset_;
   instructions_blob_stream_.WriteWord(instructions_length);
   intptr_t header_words = Image::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     instructions_blob_stream_.WriteWord(0);
   }
 
@@ skipping 23 matching lines @@
     instructions_blob_stream_.WriteWord(marked_tags);
     beginning += sizeof(uword);
 
     for (uword* cursor = reinterpret_cast<uword*>(beginning);
          cursor < reinterpret_cast<uword*>(end); cursor++) {
       instructions_blob_stream_.WriteWord(*cursor);
     }
   }
 }
 
-
 RawInstructions* ImageReader::GetInstructionsAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
 
   RawInstructions* result = reinterpret_cast<RawInstructions*>(
       reinterpret_cast<uword>(instructions_buffer_) + offset + kHeapObjectTag);
   ASSERT(result->IsInstructions());
   ASSERT(result->IsMarked());
 
   return result;
 }
 
-
 RawObject* ImageReader::GetObjectAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, kWordSize));
 
   RawObject* result = reinterpret_cast<RawObject*>(
       reinterpret_cast<uword>(data_buffer_) + offset + kHeapObjectTag);
   ASSERT(result->IsMarked());
 
   return result;
 }
 
-
 intptr_t SnapshotReader::LookupInternalClass(intptr_t class_header) {
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (IsVMIsolateObject(class_header)) {
     intptr_t class_id = GetVMIsolateObjectId(class_header);
     ASSERT(IsSingletonClassId(class_id));
     return class_id;
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   intptr_t class_id = SerializedHeaderData::decode(class_header);
   ASSERT(IsObjectStoreClassId(class_id) || IsSingletonClassId(class_id));
   return class_id;
 }
 
-
 #define READ_VM_SINGLETON_OBJ(id, obj)                                         \
   if (object_id == id) {                                                       \
     return obj;                                                                \
   }
 
 RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
   intptr_t object_id = GetVMIsolateObjectId(header_value);
 
   // First check if it is one of the singleton objects.
   READ_VM_SINGLETON_OBJ(kNullObject, Object::null());
@@ skipping 43 matching lines @@
   for (intptr_t i = 0; i < ICData::kCachedICDataArrayCount; i++) {
     if (object_id == (kCachedICDataArray0 + i)) {
       return ICData::cached_icdata_arrays_[i];
     }
   }
 
   ASSERT(Symbols::IsPredefinedSymbolId(object_id));
   return Symbols::GetPredefinedSymbol(object_id);  // return VM symbol.
 }
 
-
 RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id,
                                              intptr_t patch_object_id,
                                              intptr_t patch_offset) {
   intptr_t class_id = ClassIdFromObjectId(object_id);
   if (IsObjectStoreClassId(class_id)) {
     return isolate()->class_table()->At(class_id);  // get singleton class.
   }
   if (IsObjectStoreTypeId(object_id)) {
     return GetType(object_store(), object_id);  // return type obj.
   }
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = (object_id - kMaxPredefinedObjectIds);
   if (index < max_vm_isolate_object_id_) {
     return VmIsolateSnapshotObject(index);
   }
   AddPatchRecord(object_id, patch_object_id, patch_offset);
   return GetBackRef(object_id)->raw();
 }
 
-
 void SnapshotReader::AddPatchRecord(intptr_t object_id,
                                     intptr_t patch_object_id,
                                     intptr_t patch_offset) {
   if (patch_object_id != kInvalidPatchIndex) {
     ASSERT(object_id >= kMaxPredefinedObjectIds);
     intptr_t index = (object_id - kMaxPredefinedObjectIds);
     ASSERT(index >= max_vm_isolate_object_id_);
     index -= max_vm_isolate_object_id_;
     ASSERT(index < backward_references_->length());
     BackRefNode& ref = (*backward_references_)[index];
     ref.AddPatchRecord(patch_object_id, patch_offset);
   }
 }
 
-
 void SnapshotReader::ProcessDeferredCanonicalizations() {
   Type& typeobj = Type::Handle();
   TypeArguments& typeargs = TypeArguments::Handle();
   Object& newobj = Object::Handle();
   for (intptr_t i = 0; i < backward_references_->length(); i++) {
     BackRefNode& backref = (*backward_references_)[i];
     if (backref.defer_canonicalization()) {
       Object* objref = backref.reference();
       // Object should either be a type or a type argument.
       if (objref->IsType()) {
@@ skipping 24 matching lines @@
             }
           }
         }
       } else {
         ASSERT(objref->IsCanonical());
       }
     }
   }
 }
 
-
 void SnapshotReader::FixSubclassesAndImplementors() {
   Class& cls = Class::Handle(zone());
   Class& supercls = Class::Handle(zone());
   Array& interfaces = Array::Handle(zone());
   AbstractType& interface = AbstractType::Handle(zone());
   Class& interface_cls = Class::Handle(zone());
   for (intptr_t i = 0; i < backward_references_->length(); i++) {
     BackRefNode& backref = (*backward_references_)[i];
     Object* objref = backref.reference();
     if (objref->IsClass()) {
@@ skipping 10 matching lines @@
           interface ^= interfaces.At(i);
           interface_cls = interface.type_class();
           interface_cls.set_is_implemented();
           interface_cls.DisableCHAOptimizedCode(cls);
         }
       }
     }
   }
 }
 
-
 void SnapshotReader::ArrayReadFrom(intptr_t object_id,
                                    const Array& result,
                                    intptr_t len,
                                    intptr_t tags) {
   // Setup the object fields.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
   *TypeArgumentsHandle() ^=
       ReadObjectImpl(kAsInlinedObject, object_id, typeargs_offset);
   result.SetTypeArguments(*TypeArgumentsHandle());
 
   bool as_reference = RawObject::IsCanonical(tags) ? false : true;
   intptr_t offset = result.raw_ptr()->data() -
                     reinterpret_cast<RawObject**>(result.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
     *PassiveObjectHandle() =
         ReadObjectImpl(as_reference, object_id, (i + offset));
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
-
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
                                            Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kScript,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {}
 
-
 ScriptSnapshotReader::~ScriptSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
-
 MessageSnapshotReader::MessageSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kMessage,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {}
 
-
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
-
 SnapshotWriter::SnapshotWriter(Thread* thread,
                                Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                DeAlloc dealloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
                                bool can_send_any_object)
     : BaseWriter(buffer, alloc, dealloc, initial_size),
       thread_(thread),
       kind_(kind),
       object_store_(isolate()->object_store()),
       class_table_(isolate()->class_table()),
       forward_list_(forward_list),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       can_send_any_object_(can_send_any_object) {
   ASSERT(forward_list_ != NULL);
 }
 
-
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
-
 uint32_t SnapshotWriter::GetObjectTags(RawObject* raw) {
   return raw->ptr()->tags_;
 }
 
-
 uword SnapshotWriter::GetObjectTagsAndHash(RawObject* raw) {
   uword result = raw->ptr()->tags_;
 #if defined(HASH_IN_OBJECT_HEADER)
   result |= static_cast<uword>(raw->ptr()->hash_) << 32;
 #endif
   return result;
 }
 
-
 #define VM_OBJECT_CLASS_LIST(V)                                                \
   V(OneByteString)                                                             \
   V(TwoByteString)                                                             \
   V(Mint)                                                                      \
   V(Bigint)                                                                    \
   V(Double)                                                                    \
   V(ImmutableArray)
 
 #define VM_OBJECT_WRITE(clazz)                                                 \
   case clazz::kClassId: {                                                      \
@@ skipping 86 matching lines @@
     }
   }
 
   const Object& obj = Object::Handle(rawobj);
   FATAL1("Unexpected reference to object in VM isolate: %s\n", obj.ToCString());
   return false;
 }
 
 #undef VM_OBJECT_WRITE
 
-
 ForwardList::ForwardList(Thread* thread, intptr_t first_object_id)
     : thread_(thread),
       first_object_id_(first_object_id),
       nodes_(),
       first_unprocessed_object_id_(first_object_id) {
   ASSERT(first_object_id > 0);
 }
 
-
 ForwardList::~ForwardList() {
   heap()->ResetObjectIdTable();
 }
 
-
 intptr_t ForwardList::AddObject(Zone* zone,
                                 RawObject* raw,
                                 SerializeState state) {
   NoSafepointScope no_safepoint;
   intptr_t object_id = next_object_id();
   ASSERT(object_id > 0 && object_id <= kMaxObjectId);
   const Object& obj = Object::ZoneHandle(zone, raw);
   Node* node = new Node(&obj, state);
   ASSERT(node != NULL);
   nodes_.Add(node);
   ASSERT(object_id != 0);
   heap()->SetObjectId(raw, object_id);
   return object_id;
 }
 
-
 intptr_t ForwardList::FindObject(RawObject* raw) {
   NoSafepointScope no_safepoint;
   intptr_t id = heap()->GetObjectId(raw);
   ASSERT(id == 0 || NodeForObjectId(id)->obj()->raw() == raw);
   return (id == 0) ? static_cast<intptr_t>(kInvalidIndex) : id;
 }
 
-
 bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
   // Check if object can be written in one of the following ways:
   // - Smi: the Smi value is written as is (last bit is not tagged).
   // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
   // - Object that has already been written: (negative id in stream | 0x3)
 
   NoSafepointScope no_safepoint;
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
@@ skipping 48 matching lines @@
   RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
   intptr_t index = GetTypeIndex(object_store(), raw_type);
   if (index != kInvalidIndex) {
     WriteIndexedObject(index);
     return true;
   }
 
   return false;
 }
 
-
 void SnapshotWriter::WriteObjectImpl(RawObject* raw, bool as_reference) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   // When we know that we are dealing with leaf or shallow objects we write
   // these objects inline even when 'as_reference' is true.
   const bool write_as_reference = as_reference && !raw->IsCanonical();
   uintptr_t tags = GetObjectTagsAndHash(raw);
 
   // Add object to the forward ref list and mark it so that future references
   // to this object in the snapshot will use this object id. Mark the
   // serialization state so that we do the right thing when we go through
   // the forward list.
   intptr_t class_id = raw->GetClassId();
   intptr_t object_id;
   if (write_as_reference && IsSplitClassId(class_id)) {
     object_id = forward_list_->AddObject(zone(), raw, kIsNotSerialized);
   } else {
     object_id = forward_list_->AddObject(zone(), raw, kIsSerialized);
   }
   if (write_as_reference || !IsSplitClassId(class_id)) {
     object_id = kOmittedObjectId;
   }
   WriteMarkedObjectImpl(raw, tags, object_id, write_as_reference);
 }
 
-
 void SnapshotWriter::WriteMarkedObjectImpl(RawObject* raw,
                                            intptr_t tags,
                                            intptr_t object_id,
                                            bool as_reference) {
   NoSafepointScope no_safepoint;
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   intptr_t class_id = cls->ptr()->id_;
   ASSERT(class_id == RawObject::ClassIdTag::decode(tags));
   if (class_id >= kNumPredefinedCids ||
       RawObject::IsImplicitFieldClassId(class_id)) {
@@ skipping 28 matching lines @@
     }
 #undef SNAPSHOT_WRITE
     default:
       break;
   }
 
   const Object& obj = Object::Handle(raw);
   FATAL1("Unexpected object: %s\n", obj.ToCString());
 }
 
-
 class WriteInlinedObjectVisitor : public ObjectVisitor {
  public:
   explicit WriteInlinedObjectVisitor(SnapshotWriter* writer)
       : writer_(writer) {}
 
   virtual void VisitObject(RawObject* obj) {
     intptr_t object_id = writer_->forward_list_->FindObject(obj);
     ASSERT(object_id != kInvalidIndex);
     intptr_t tags = MessageWriter::GetObjectTagsAndHash(obj);
     writer_->WriteMarkedObjectImpl(obj, tags, object_id, kAsInlinedObject);
   }
 
  private:
   SnapshotWriter* writer_;
 };
 
-
 void SnapshotWriter::WriteForwardedObjects() {
   WriteInlinedObjectVisitor visitor(this);
   forward_list_->SerializeAll(&visitor);
 }
 
-
 void ForwardList::SerializeAll(ObjectVisitor* writer) {
 // Write out all objects that were added to the forward list and have
 // not been serialized yet. These would typically be fields of instance
 // objects, arrays or immutable arrays (this is done in order to avoid
 // deep recursive calls to WriteObjectImpl).
 // NOTE: The forward list might grow as we process the list.
 #ifdef DEBUG
   for (intptr_t i = first_object_id(); i < first_unprocessed_object_id_; ++i) {
     ASSERT(NodeForObjectId(i)->is_serialized());
   }
 #endif  // DEBUG
   for (intptr_t id = first_unprocessed_object_id_; id < next_object_id();
        ++id) {
     if (!NodeForObjectId(id)->is_serialized()) {
       // Write the object out in the stream.
       RawObject* raw = NodeForObjectId(id)->obj()->raw();
       writer->VisitObject(raw);
 
       // Mark object as serialized.
       NodeForObjectId(id)->set_state(kIsSerialized);
     }
   }
   first_unprocessed_object_id_ = next_object_id();
 }
 
-
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(!Snapshot::IsFull(kind_));
   int class_id = cls->ptr()->id_;
   ASSERT(!IsSingletonClassId(class_id) && !IsObjectStoreClassId(class_id));
 
   // Write out the library url and class name.
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
   WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
   WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
 }
 
-
 void SnapshotWriter::WriteFunctionId(RawFunction* func, bool owner_is_class) {
   ASSERT(kind_ == Snapshot::kScript);
   RawClass* cls = (owner_is_class)
                       ? reinterpret_cast<RawClass*>(func->ptr()->owner_)
                       : reinterpret_cast<RawPatchClass*>(func->ptr()->owner_)
                             ->ptr()
                             ->patched_class_;
 
   // Write out the library url and class name.
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
   WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
   WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
   WriteObjectImpl(func->ptr()->name_, kAsInlinedObject);
 }
 
-
 void SnapshotWriter::WriteStaticImplicitClosure(intptr_t object_id,
                                                 RawFunction* func,
                                                 intptr_t tags) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Indicate this is a static implicit closure object.
   Write<int32_t>(SerializedHeaderData::encode(kStaticImplicitClosureObjectId));
 
   // Write out the tags.
   WriteTags(tags);
 
   // Write out the library url, class name and signature function name.
   RawClass* cls = GetFunctionOwner(func);
   ASSERT(cls != Class::null());
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
   WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
   WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
   WriteObjectImpl(func->ptr()->name_, kAsInlinedObject);
 }
 
-
 void SnapshotWriter::ArrayWriteTo(intptr_t object_id,
                                   intptr_t array_kind,
                                   intptr_t tags,
                                   RawSmi* length,
                                   RawTypeArguments* type_arguments,
                                   RawObject* data[],
                                   bool as_reference) {
   if (as_reference) {
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(kOmittedObjectId);
@@ skipping 21 matching lines @@
     WriteObjectImpl(type_arguments, kAsInlinedObject);
 
     // Write out the individual object ids.
     bool write_as_reference = RawObject::IsCanonical(tags) ? false : true;
     for (intptr_t i = 0; i < len; i++) {
       WriteObjectImpl(data[i], write_as_reference);
     }
   }
 }
 
-
 RawFunction* SnapshotWriter::IsSerializableClosure(RawClosure* closure) {
   // Extract the function object to check if this closure
   // can be sent in an isolate message.
   RawFunction* func = closure->ptr()->function_;
   // We only allow closure of top level methods or static functions in a
   // class to be sent in isolate messages.
   if (can_send_any_object() &&
       Function::IsImplicitStaticClosureFunction(func)) {
     return func;
   }
   // Not a closure of a top level method or static function, throw an
   // exception as we do not allow these objects to be serialized.
   HANDLESCOPE(thread());
 
   const Function& errorFunc = Function::Handle(zone(), func);
   ASSERT(!errorFunc.IsNull());
 
   // All other closures are errors.
   char* chars = OS::SCreate(
       thread()->zone(),
       "Illegal argument in isolate message : (object is a closure - %s)",
       errorFunc.ToCString());
   SetWriteException(Exceptions::kArgument, chars);
   return Function::null();
 }
 
-
 RawClass* SnapshotWriter::GetFunctionOwner(RawFunction* func) {
   RawObject* owner = func->ptr()->owner_;
   uint32_t tags = GetObjectTags(owner);
   intptr_t class_id = RawObject::ClassIdTag::decode(tags);
   if (class_id == kClassCid) {
     return reinterpret_cast<RawClass*>(owner);
   }
   ASSERT(class_id == kPatchClassCid);
   return reinterpret_cast<RawPatchClass*>(owner)->ptr()->patched_class_;
 }
 
-
 void SnapshotWriter::CheckForNativeFields(RawClass* cls) {
   if (cls->ptr()->num_native_fields_ != 0) {
     // We do not allow objects with native fields in an isolate message.
     HANDLESCOPE(thread());
     const Class& clazz = Class::Handle(zone(), cls);
     char* chars = OS::SCreate(thread()->zone(),
                               "Illegal argument in isolate message"
                               " : (object extends NativeWrapper - %s)",
                               clazz.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
 }
 
-
 void SnapshotWriter::SetWriteException(Exceptions::ExceptionType type,
                                        const char* msg) {
   set_exception_type(type);
   set_exception_msg(msg);
   // The more specific error is set up in SnapshotWriter::ThrowException().
   thread()->long_jump_base()->Jump(1, Object::snapshot_writer_error());
 }
 
-
 void SnapshotWriter::WriteInstance(RawObject* raw,
                                    RawClass* cls,
                                    intptr_t tags,
                                    intptr_t object_id,
                                    bool as_reference) {
   // Closure instances are handled by RawClosure::WriteTo().
   ASSERT(!Class::IsClosureClass(cls));
 
   // Check if the instance has native fields and throw an exception if it does.
   CheckForNativeFields(cls);
@@ skipping 34 matching lines @@
     while (offset < next_field_offset) {
       RawObject* raw_obj = *reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset);
       WriteObjectImpl(raw_obj, write_as_reference);
       offset += kWordSize;
     }
   }
   return;
 }
 
-
 bool SnapshotWriter::AllowObjectsInDartLibrary(RawLibrary* library) {
   return (library == object_store()->collection_library() ||
           library == object_store()->core_library() ||
           library == object_store()->typed_data_library());
 }
 
-
 intptr_t SnapshotWriter::FindVmSnapshotObject(RawObject* rawobj) {
   intptr_t length = Object::vm_isolate_snapshot_object_table().Length();
   for (intptr_t i = 0; i < length; i++) {
     if (Object::vm_isolate_snapshot_object_table().At(i) == rawobj) {
       return (i + kMaxPredefinedObjectIds);
     }
   }
   return kInvalidIndex;
 }
 
-
 void SnapshotWriter::ThrowException(Exceptions::ExceptionType type,
                                     const char* msg) {
   thread()->clear_sticky_error();
   if (msg != NULL) {
     const String& msg_obj = String::Handle(String::New(msg));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, msg_obj);
     Exceptions::ThrowByType(type, args);
   } else {
     Exceptions::ThrowByType(type, Object::empty_array());
   }
   UNREACHABLE();
 }
 
-
 void SnapshotWriter::WriteVersionAndFeatures() {
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_version), version_len);
 
   const char* expected_features =
       Dart::FeaturesString(Isolate::Current(), kind_);
   ASSERT(expected_features != NULL);
   const intptr_t features_len = strlen(expected_features);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_features),
              features_len + 1);
   free(const_cast<char*>(expected_features));
 }
 
-
 ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kScript,
                      buffer,
                      alloc,
                      NULL,
                      kInitialSize,
                      &forward_list_,
                      true /* can_send_any_object */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
-
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     ReserveHeader();
 
     // Write out the version string.
     WriteVersionAndFeatures();
 
     // Write out the library object.
     {
       NoSafepointScope no_safepoint;
 
       // Write out the library object.
       WriteObject(lib.raw());
 
       FillHeader(kind());
     }
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
-
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObjectImpl(raw_obj, as_references_);
   }
 }
 
-
 MessageWriter::MessageWriter(uint8_t** buffer,
                              ReAlloc alloc,
                              DeAlloc dealloc,
                              bool can_send_any_object,
                              intptr_t* buffer_len)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kMessage,
                      buffer,
                      alloc,
                      dealloc,
                      kInitialSize,
                      &forward_list_,
                      can_send_any_object),
       forward_list_(thread(), kMaxPredefinedObjectIds),
       buffer_len_(buffer_len) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
-
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     if (buffer_len_ != NULL) {
       *buffer_len_ = BytesWritten();
     }
   } else {
     FreeBuffer();
     ThrowException(exception_type(), exception_msg());
   }
 }
 
-
 }  // namespace dart