clang-format runtime/vm

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"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
 #include "vm/version.h"
 
 // We currently only expect the Dart mutator to read snapshots.
-#define ASSERT_NO_SAFEPOINT_SCOPE()                            \
-    isolate()->AssertCurrentThreadIsMutator();                 \
-    ASSERT(thread()->no_safepoint_scope_depth() != 0)
+#define ASSERT_NO_SAFEPOINT_SCOPE()                                            \
+  isolate()->AssertCurrentThreadIsMutator();                                   \
+  ASSERT(thread()->no_safepoint_scope_depth() != 0)
 
 namespace dart {
 
 static const int kNumInitialReferences = 64;
 
 
 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));
@@ skipping 15 matching lines @@
 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 ||
+  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();
-    case kSmiType: return object_store->smi_type();
-    case kMintType: return object_store->mint_type();
-    case kDoubleType: return object_store->double_type();
-    case kIntType: return object_store->int_type();
-    case kBoolType: return object_store->bool_type();
-    case kStringType: return object_store->string_type();
-    case kArrayType: return object_store->array_type();
-    default: break;
+    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();
+    case kSmiType:
+      return object_store->smi_type();
+    case kMintType:
+      return object_store->mint_type();
+    case kDoubleType:
+      return object_store->double_type();
+    case kIntType:
+      return object_store->int_type();
+    case kBoolType:
+      return object_store->bool_type();
+    case kStringType:
+      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) {
+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()) {
@@ skipping 39 matching lines @@
   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)
+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()),
       old_space_(thread_->isolate()->heap()->old_space()),
       cls_(Class::Handle(zone_)),
       obj_(Object::Handle(zone_)),
       pobj_(PassiveObject::Handle(zone_)),
       array_(Array::Handle(zone_)),
       field_(Field::Handle(zone_)),
       str_(String::Handle(zone_)),
       library_(Library::Handle(zone_)),
       type_(AbstractType::Handle(zone_)),
       type_arguments_(TypeArguments::Handle(zone_)),
       tokens_(GrowableObjectArray::Handle(zone_)),
       stream_(TokenStream::Handle(zone_)),
       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) {
-}
+          (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()) {
@@ skipping 112 matching lines @@
   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_;
+  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);
+  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);
+  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);
+                             patch_object_id, patch_offset);
   }
   ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
   intptr_t object_id = SerializedHeaderData::decode(header_value);
   if (object_id == kOmittedObjectId) {
     object_id = NextAvailableObjectId();
   }
 
   // Read the class header information.
   intptr_t class_header = Read<int32_t>();
   intptr_t tags = ReadTags();
   bool read_as_reference = as_reference && !RawObject::IsCanonical(tags);
   intptr_t header_id = SerializedHeaderData::decode(class_header);
   if (header_id == kInstanceObjectId) {
     return ReadInstance(object_id, tags, read_as_reference);
   } else if (header_id == kStaticImplicitClosureObjectId) {
     // We skip the tags that have been written as the implicit static
     // closure is going to be created in this isolate or the canonical
     // version already created in the isolate will be used.
     return ReadStaticImplicitClosure(object_id, class_header);
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
 
   intptr_t class_id = LookupInternalClass(class_header);
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
-    case clazz::kClassId: {                                                    \
-      pobj_ = clazz::ReadFrom(this, object_id, tags, kind_, read_as_reference);\
-      break;                                                                   \
-    }
+  case clazz::kClassId: {                                                      \
+    pobj_ = clazz::ReadFrom(this, object_id, tags, kind_, read_as_reference);  \
+    break;                                                                     \
+  }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
-#define SNAPSHOT_READ(clazz)                                                   \
-        case kTypedData##clazz##Cid:                                           \
+#define SNAPSHOT_READ(clazz) case kTypedData##clazz##Cid:
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(class_id, tags);
-      pobj_ = TypedData::ReadFrom(
-          this, object_id, tags, kind_, read_as_reference);
+      pobj_ =
+          TypedData::ReadFrom(this, object_id, tags, kind_, read_as_reference);
       break;
     }
 #undef SNAPSHOT_READ
-#define SNAPSHOT_READ(clazz)                                                   \
-    case kExternalTypedData##clazz##Cid:                                       \
+#define SNAPSHOT_READ(clazz) case kExternalTypedData##clazz##Cid:
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(class_id, tags);
       pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_, true);
       break;
     }
 #undef SNAPSHOT_READ
-    default: UNREACHABLE(); break;
+    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,
@@ skipping 32 matching lines @@
     ASSERT(next_field_offset > 0);
     // Instance::NextFieldOffset() returns the offset of the first field in
     // a Dart object.
     bool read_as_reference = RawObject::IsCanonical(tags) ? false : true;
     intptr_t offset = Instance::NextFieldOffset();
     intptr_t result_cid = result->GetClassId();
     while (offset < next_field_offset) {
       pobj_ = ReadObjectImpl(read_as_reference);
       result->SetFieldAtOffset(offset, pobj_);
       if ((offset != type_argument_field_offset) &&
-          (kind_ == Snapshot::kMessage) &&
-          FLAG_use_field_guards) {
+          (kind_ == Snapshot::kMessage) && FLAG_use_field_guards) {
         // TODO(fschneider): Consider hoisting these lookups out of the loop.
         // This would involve creating a handle, since cls_ can't be reused
         // across the call to ReadObjectImpl.
         cls_ = isolate()->class_table()->At(result_cid);
         array_ = cls_.OffsetToFieldMap();
         field_ ^= array_.At(offset >> kWordSizeLog2);
         ASSERT(!field_.IsNull());
         ASSERT(field_.Offset() == offset);
         obj_ = pobj_.raw();
         field_.RecordStore(obj_);
@@ skipping 33 matching lines @@
     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();
+    page_space_->AcquireDataLock();
   }
-  ~HeapLocker() {
-    page_space_->ReleaseDataLock();
-  }
+  ~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();
   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,
+      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() {
   // 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];
-    OS::SNPrint(message_buffer,
-                kMessageBufferSize,
+    OS::SNPrint(message_buffer, kMessageBufferSize,
                 "No full snapshot version found, expected '%s'",
                 expected_version);
     // 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);
   }
 
   const char* version = reinterpret_cast<const char*>(CurrentBufferAddress());
   ASSERT(version != NULL);
   if (strncmp(version, expected_version, version_len)) {
     const intptr_t kMessageBufferSize = 256;
     char message_buffer[kMessageBufferSize];
     char* actual_version = OS::StrNDup(version, version_len);
-    OS::SNPrint(message_buffer,
-                kMessageBufferSize,
+    OS::SNPrint(message_buffer, kMessageBufferSize,
                 "Wrong %s snapshot version, expected '%s' found '%s'",
-                (Snapshot::IsFull(kind_)) ? "full" : "script",
-                expected_version,
+                (Snapshot::IsFull(kind_)) ? "full" : "script", expected_version,
                 actual_version);
     free(actual_version);
     // 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);
   }
   Advance(version_len);
 
   const char* expected_features = Dart::FeaturesString(kind_);
   ASSERT(expected_features != NULL);
   const intptr_t expected_len = strlen(expected_features);
 
   const char* features = reinterpret_cast<const char*>(CurrentBufferAddress());
   ASSERT(features != NULL);
   intptr_t buffer_len = OS::StrNLen(features, PendingBytes());
   if ((buffer_len != expected_len) ||
       strncmp(features, expected_features, expected_len)) {
     const intptr_t kMessageBufferSize = 256;
     char message_buffer[kMessageBufferSize];
-    char* actual_features = OS::StrNDup(features, buffer_len < 128 ? buffer_len
-                                                                   : 128);
-    OS::SNPrint(message_buffer,
-                kMessageBufferSize,
+    char* actual_features =
+        OS::StrNDup(features, buffer_len < 128 ? buffer_len : 128);
+    OS::SNPrint(message_buffer, kMessageBufferSize,
                 "Wrong features in snapshot, expected '%s' found '%s'",
-                expected_features,
-                actual_features);
+                expected_features, actual_features);
     free(const_cast<char*>(expected_features));
     free(actual_features);
     // 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();
@@ skipping 35 matching lines @@
   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;
 }
 
 
 static void EnsureIdentifier(char* label) {
   for (char c = *label; c != '\0'; c = *++label) {
-    if (((c >= 'a') && (c <= 'z')) ||
-        ((c >= 'A') && (c <= 'Z')) ||
+    if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
       continue;
     }
     *label = '_';
   }
 }
 
 
 void AssemblyInstructionsWriter::Write(uint8_t* vmisolate_buffer,
                                        intptr_t vmisolate_length,
                                        uint8_t* isolate_buffer,
                                        intptr_t isolate_length) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  NOT_IN_PRODUCT(TimelineDurationScope tds(thread,
-      Timeline::GetIsolateStream(), "WriteInstructions"));
+  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++) {
@@ skipping 38 matching lines @@
 
       // Write Instructions with the mark and VM heap bits set.
       uword marked_tags = insns.raw_ptr()->tags_;
       marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
       marked_tags = RawObject::MarkBit::update(true, marked_tags);
 
       WriteWordLiteralText(marked_tags);
       beginning += sizeof(uword);
 
       for (uword* cursor = reinterpret_cast<uword*>(beginning);
-           cursor < reinterpret_cast<uword*>(entry);
-           cursor++) {
+           cursor < reinterpret_cast<uword*>(entry); cursor++) {
         WriteWordLiteralText(*cursor);
       }
     }
 
     // 2. Write a label at the entry point.
     owner = code.owner();
     if (owner.IsNull()) {
       const char* name = StubCode::NameOfStub(insns.UncheckedEntryPoint());
       assembly_stream_.Print("Precompiled_Stub_%s:\n", name);
     } else if (owner.IsClass()) {
       str = Class::Cast(owner).Name();
       const char* name = str.ToCString();
       EnsureIdentifier(const_cast<char*>(name));
-      assembly_stream_.Print("Precompiled_AllocationStub_%s_%" Pd ":\n",
-                             name, i);
+      assembly_stream_.Print("Precompiled_AllocationStub_%s_%" Pd ":\n", name,
+                             i);
     } else if (owner.IsFunction()) {
       const char* name = Function::Cast(owner).ToQualifiedCString();
       EnsureIdentifier(const_cast<char*>(name));
       assembly_stream_.Print("Precompiled_%s_%" Pd ":\n", name, i);
     } else {
       UNREACHABLE();
     }
 
     {
       // 3. Write from the entry point to the end.
       NoSafepointScope no_safepoint;
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
       uword payload_size = insns.size();
       payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
       uword end = entry + payload_size;
 
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
       for (uword* cursor = reinterpret_cast<uword*>(entry);
-           cursor < reinterpret_cast<uword*>(end);
-           cursor++) {
+           cursor < reinterpret_cast<uword*>(end); cursor++) {
         WriteWordLiteralText(*cursor);
       }
     }
   }
 #if defined(TARGET_OS_LINUX)
   assembly_stream_.Print(".section .rodata\n");
 #elif defined(TARGET_OS_MACOS)
   assembly_stream_.Print(".const\n");
 #else
   // Unsupported platform.
@@ skipping 16 matching lines @@
     uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
     uword end = start + obj.raw()->Size();
 
     // Write object header with the mark and VM heap bits set.
     uword marked_tags = obj.raw()->ptr()->tags_;
     marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
     marked_tags = RawObject::MarkBit::update(true, marked_tags);
     WriteWordLiteralData(marked_tags);
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
-         cursor < reinterpret_cast<uword*>(end);
-         cursor++) {
+         cursor < reinterpret_cast<uword*>(end); cursor++) {
       WriteWordLiteralData(*cursor);
     }
   }
 
 
   assembly_stream_.Print(".globl _kVmIsolateSnapshot\n");
   assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
   assembly_stream_.Print("_kVmIsolateSnapshot:\n");
   for (intptr_t i = 0; i < vmisolate_length; i++) {
     assembly_stream_.Print(".byte %" Pd "\n", vmisolate_buffer[i]);
   }
 
   assembly_stream_.Print(".globl _kIsolateSnapshot\n");
   assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
   assembly_stream_.Print("_kIsolateSnapshot:\n");
   for (intptr_t i = 0; i < isolate_length; i++) {
     assembly_stream_.Print(".byte %" Pd "\n", isolate_buffer[i]);
   }
 }
 
 
 void BlobInstructionsWriter::Write(uint8_t* vmisolate_buffer,
                                    intptr_t vmisolate_len,
                                    uint8_t* isolate_buffer,
                                    intptr_t isolate_length) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  NOT_IN_PRODUCT(TimelineDurationScope tds(thread,
-      Timeline::GetIsolateStream(), "WriteInstructions"));
+  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++) {
@@ skipping 25 matching lines @@
 
       // Write Instructions with the mark and VM heap bits set.
       uword marked_tags = insns.raw_ptr()->tags_;
       marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
       marked_tags = RawObject::MarkBit::update(true, marked_tags);
 
       instructions_blob_stream_.WriteWord(marked_tags);
       beginning += sizeof(uword);
 
       for (uword* cursor = reinterpret_cast<uword*>(beginning);
-           cursor < reinterpret_cast<uword*>(entry);
-           cursor++) {
+           cursor < reinterpret_cast<uword*>(entry); cursor++) {
         instructions_blob_stream_.WriteWord(*cursor);
       }
     }
 
     // 2. Write from the entry point to the end.
     {
       NoSafepointScope no_safepoint;
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
       uword payload_size = insns.size();
       payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
       uword end = entry + payload_size;
 
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
       for (uword* cursor = reinterpret_cast<uword*>(entry);
-           cursor < reinterpret_cast<uword*>(end);
-           cursor++) {
+           cursor < reinterpret_cast<uword*>(end); cursor++) {
         instructions_blob_stream_.WriteWord(*cursor);
       }
     }
   }
 
   rodata_blob_stream_.WriteWord(next_object_offset_);  // Data length.
   COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
   while (!Utils::IsAligned(rodata_blob_stream_.bytes_written(),
                            OS::kMaxPreferredCodeAlignment)) {
     rodata_blob_stream_.WriteWord(0);
   }
 
   for (intptr_t i = 0; i < objects_.length(); i++) {
     const Object& obj = *objects_[i].obj_;
 
     NoSafepointScope no_safepoint;
     uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
     uword end = start + obj.raw()->Size();
 
     // Write object header with the mark and VM heap bits set.
     uword marked_tags = obj.raw()->ptr()->tags_;
     marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
     marked_tags = RawObject::MarkBit::update(true, marked_tags);
     rodata_blob_stream_.WriteWord(marked_tags);
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
-         cursor < reinterpret_cast<uword*>(end);
-         cursor++) {
+         cursor < reinterpret_cast<uword*>(end); cursor++) {
       rodata_blob_stream_.WriteWord(*cursor);
     }
   }
 }
 
 
 uword InstructionsReader::GetInstructionsAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
   return reinterpret_cast<uword>(instructions_buffer_) + offset;
 }
 
 
 RawObject* InstructionsReader::GetObjectAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, kWordSize));
 
-  RawObject* result =
-      reinterpret_cast<RawObject*>(
-          reinterpret_cast<uword>(data_buffer_) + offset + kHeapObjectTag);
+  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());
   READ_VM_SINGLETON_OBJ(kSentinelObject, Object::sentinel().raw());
   READ_VM_SINGLETON_OBJ(kTransitionSentinelObject,
                         Object::transition_sentinel().raw());
   READ_VM_SINGLETON_OBJ(kEmptyArrayObject, Object::empty_array().raw());
@@ skipping 98 matching lines @@
         typeargs ^= objref->raw();
         newobj = typeargs.Canonicalize();
       }
       if (newobj.raw() != objref->raw()) {
         ZoneGrowableArray<intptr_t>* patches = backref.patch_records();
         ASSERT(newobj.IsCanonical());
         ASSERT(patches != NULL);
         // First we replace the back ref table with the canonical object.
         *objref = newobj.raw();
         // Now we go over all the patch records and patch the canonical object.
-        for (intptr_t j = 0; j < patches->length(); j+=2) {
+        for (intptr_t j = 0; j < patches->length(); j += 2) {
           NoSafepointScope no_safepoint;
           intptr_t patch_object_id = (*patches)[j];
           intptr_t patch_offset = (*patches)[j + 1];
           Object* target = GetBackRef(patch_object_id);
           // We should not backpatch an object that is canonical.
           if (!target->IsCanonical()) {
             RawObject** rawptr =
                 reinterpret_cast<RawObject**>(target->raw()->ptr());
             target->StorePointer((rawptr + patch_offset), newobj.raw());
           }
         }
       } else {
         ASSERT(objref->IsCanonical());
       }
     }
   }
 }
 
 
 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);
+  *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());
+                    reinterpret_cast<RawObject**>(result.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
-    *PassiveObjectHandle() = ReadObjectImpl(as_reference,
-                                            object_id,
-                                            (i + offset));
+    *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) {
-}
+                     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) {
-}
+                     thread) {}
 
 
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 SnapshotWriter::SnapshotWriter(Thread* thread,
                                Snapshot::Kind kind,
                                uint8_t** buffer,
@@ skipping 24 matching lines @@
   return raw->ptr()->tags_;
 }
 
 
 #define VM_OBJECT_CLASS_LIST(V)                                                \
   V(OneByteString)                                                             \
   V(TwoByteString)                                                             \
   V(Mint)                                                                      \
   V(Bigint)                                                                    \
   V(Double)                                                                    \
-  V(ImmutableArray)                                                            \
+  V(ImmutableArray)
 
 #define VM_OBJECT_WRITE(clazz)                                                 \
   case clazz::kClassId: {                                                      \
     object_id = forward_list_->AddObject(zone(), rawobj, kIsSerialized);       \
     Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(rawobj);               \
-        raw_obj->WriteTo(this, object_id, kind(), false);                      \
+    raw_obj->WriteTo(this, object_id, kind(), false);                          \
     return true;                                                               \
-  }                                                                            \
+  }
 
 #define WRITE_VM_SINGLETON_OBJ(obj, id)                                        \
   if (rawobj == obj) {                                                         \
     WriteVMIsolateObject(id);                                                  \
     return true;                                                               \
-  }                                                                            \
+  }
 
 bool SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
   // Check if it is one of the singleton VM objects.
   WRITE_VM_SINGLETON_OBJ(Object::null(), kNullObject);
   WRITE_VM_SINGLETON_OBJ(Object::sentinel().raw(), kSentinelObject);
   WRITE_VM_SINGLETON_OBJ(Object::transition_sentinel().raw(),
                          kTransitionSentinelObject);
   WRITE_VM_SINGLETON_OBJ(Object::empty_array().raw(), kEmptyArrayObject);
   WRITE_VM_SINGLETON_OBJ(Object::zero_array().raw(), kZeroArrayObject);
   WRITE_VM_SINGLETON_OBJ(Object::dynamic_type().raw(), kDynamicType);
@@ skipping 71 matching lines @@
 
 #undef VM_OBJECT_WRITE
 
 
 // An object visitor which will iterate over all the script objects in the heap
 // and either count them or collect them into an array. This is used during
 // full snapshot generation of the VM isolate to write out all script
 // objects and their accompanying token streams.
 class ScriptVisitor : public ObjectVisitor {
  public:
-  explicit ScriptVisitor(Thread* thread) :
-      objHandle_(Object::Handle(thread->zone())),
-      count_(0),
-      scripts_(NULL) {}
+  explicit ScriptVisitor(Thread* thread)
+      : objHandle_(Object::Handle(thread->zone())), count_(0), scripts_(NULL) {}
 
-  ScriptVisitor(Thread* thread, const Array* scripts) :
-      objHandle_(Object::Handle(thread->zone())),
-      count_(0),
-      scripts_(scripts) {}
+  ScriptVisitor(Thread* thread, const Array* scripts)
+      : objHandle_(Object::Handle(thread->zone())),
+        count_(0),
+        scripts_(scripts) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsScript()) {
       if (scripts_ != NULL) {
         objHandle_ = obj;
         scripts_->SetAt(count_, objHandle_);
       }
       count_ += 1;
     }
   }
@@ skipping 151 matching lines @@
   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)) {
     WriteInstance(raw, cls, tags, object_id, as_reference);
     return;
   }
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
-    case clazz::kClassId: {                                                    \
-      Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
-          raw_obj->WriteTo(this, object_id, kind_, as_reference);              \
-      return;                                                                  \
-    }                                                                          \
+  case clazz::kClassId: {                                                      \
+    Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                  \
+    raw_obj->WriteTo(this, object_id, kind_, as_reference);                    \
+    return;                                                                    \
+  }
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
-#define SNAPSHOT_WRITE(clazz)                                                  \
-    case kTypedData##clazz##Cid:                                               \
+#define SNAPSHOT_WRITE(clazz) case kTypedData##clazz##Cid:
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
       RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(raw);
       raw_obj->WriteTo(this, object_id, kind_, as_reference);
       return;
     }
 #undef SNAPSHOT_WRITE
-#define SNAPSHOT_WRITE(clazz)                                                  \
-    case kExternalTypedData##clazz##Cid:                                       \
+#define SNAPSHOT_WRITE(clazz) case kExternalTypedData##clazz##Cid:
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
       RawExternalTypedData* raw_obj =
-        reinterpret_cast<RawExternalTypedData*>(raw);
+          reinterpret_cast<RawExternalTypedData*>(raw);
       raw_obj->WriteTo(this, object_id, kind_, as_reference);
       return;
     }
 #undef SNAPSHOT_WRITE
-    default: break;
+    default:
+      break;
   }
 
   const Object& obj = Object::Handle(raw);
   FATAL1("Unexpected object: %s\n", obj.ToCString());
 }
 
 
 class WriteInlinedObjectVisitor : public ObjectVisitor {
  public:
   explicit WriteInlinedObjectVisitor(SnapshotWriter* writer)
@@ skipping 11 matching lines @@
 };
 
 
 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.
+// 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();
+  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_;
+  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);
 }
 
 
@@ skipping 73 matching lines @@
     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(),
+  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_;
   uword 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());
+                              "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());
+  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);
 
   // Object is regular dart instance.
   if (as_reference) {
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Indicate this is an instance object.
     Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
     WriteTags(tags);
 
     // Write out the class information for this object.
     WriteObjectImpl(cls, kAsInlinedObject);
   } else {
-    intptr_t next_field_offset =
-        cls->ptr()->next_field_offset_in_words_ << kWordSizeLog2;
+    intptr_t next_field_offset = cls->ptr()->next_field_offset_in_words_
+                                 << kWordSizeLog2;
     ASSERT(next_field_offset > 0);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
     Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
 
     // Write out the tags.
     WriteTags(tags);
@@ skipping 58 matching lines @@
 
   const char* expected_features = Dart::FeaturesString(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)
+ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
                      true /* can_send_any_object */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
@@ skipping 64 matching lines @@
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart