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

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, 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/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/bit_vector.h"
-#include "vm/runtime_entry.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
+#include "vm/runtime_entry.h"
 #include "vm/safepoint.h"
 #include "vm/service_event.h"
 #include "vm/stack_frame.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_reload, false, "Trace isolate reloading");
@@ skipping 18 matching lines @@
             "Assert that an isolate has reloaded at least once.")
 #ifndef PRODUCT
 
 #define I (isolate())
 #define Z (thread->zone())
 
 #define TIMELINE_SCOPE(name)                                                   \
   TimelineDurationScope tds##name(Thread::Current(),                           \
                                   Timeline::GetIsolateStream(), #name)
 
-
 InstanceMorpher::InstanceMorpher(Zone* zone, const Class& from, const Class& to)
     : from_(Class::Handle(zone, from.raw())),
       to_(Class::Handle(zone, to.raw())),
       mapping_(zone, 0) {
   before_ = new (zone) ZoneGrowableArray<const Instance*>(zone, 0);
   after_ = new (zone) ZoneGrowableArray<const Instance*>(zone, 0);
   new_fields_ = new (zone) ZoneGrowableArray<const Field*>(zone, 0);
   ASSERT(from_.id() == to_.id());
   cid_ = from_.id();
   ComputeMapping();
 }
 
-
 void InstanceMorpher::AddObject(RawObject* object) const {
   ASSERT(object->GetClassId() == cid());
   const Instance& instance = Instance::Cast(Object::Handle(object));
   before_->Add(&instance);
 }
 
-
 void InstanceMorpher::ComputeMapping() {
   if (from_.NumTypeArguments()) {
     // Add copying of the optional type argument field.
     intptr_t from_offset = from_.type_arguments_field_offset();
     ASSERT(from_offset != Class::kNoTypeArguments);
     intptr_t to_offset = to_.type_arguments_field_offset();
     ASSERT(to_offset != Class::kNoTypeArguments);
     mapping_.Add(from_offset);
     mapping_.Add(to_offset);
   }
@@ skipping 42 matching lines @@
     if (new_field) {
       if (to_field.has_initializer()) {
         // This is a new field with an initializer.
         const Field& field = Field::Handle(to_field.raw());
         new_fields_->Add(&field);
       }
     }
   }
 }
 
-
 RawInstance* InstanceMorpher::Morph(const Instance& instance) const {
   const Instance& result = Instance::Handle(Instance::New(to_));
   // Morph the context from instance to result using mapping_.
   for (intptr_t i = 0; i < mapping_.length(); i += 2) {
     intptr_t from_offset = mapping_.At(i);
     intptr_t to_offset = mapping_.At(i + 1);
     const Object& value =
         Object::Handle(instance.RawGetFieldAtOffset(from_offset));
     result.RawSetFieldAtOffset(to_offset, value);
   }
   // Convert the instance into a filler object.
   Become::MakeDummyObject(instance);
   return result.raw();
 }
 
-
 void InstanceMorpher::RunNewFieldInitializers() const {
   if ((new_fields_->length() == 0) || (after_->length() == 0)) {
     return;
   }
 
   TIR_Print("Running new field initializers for class: %s\n", to_.ToCString());
   String& initializing_expression = String::Handle();
   Function& eval_func = Function::Handle();
   Object& result = Object::Handle();
   Class& owning_class = Class::Handle();
@@ skipping 21 matching lines @@
             "RELOAD: Running initializer for new field `%s` resulted in "
             "an error: %s\n",
             field->ToCString(), Error::Cast(result).ToErrorCString());
         continue;
       }
       instance->RawSetFieldAtOffset(field->Offset(), result);
     }
   }
 }
 
-
 void InstanceMorpher::CreateMorphedCopies() const {
   for (intptr_t i = 0; i < before()->length(); i++) {
     const Instance& copy = Instance::Handle(Morph(*before()->At(i)));
     after()->Add(&copy);
   }
 }
 
-
 void InstanceMorpher::DumpFormatFor(const Class& cls) const {
   THR_Print("%s\n", cls.ToCString());
   if (cls.NumTypeArguments()) {
     intptr_t field_offset = cls.type_arguments_field_offset();
     ASSERT(field_offset != Class::kNoTypeArguments);
     THR_Print("  - @%" Pd " <type arguments>\n", field_offset);
   }
   const Array& fields = Array::Handle(cls.OffsetToFieldMap());
   Field& field = Field::Handle();
   String& name = String::Handle();
   for (intptr_t i = 0; i < fields.Length(); i++) {
     if (fields.At(i) != Field::null()) {
       field = Field::RawCast(fields.At(i));
       ASSERT(field.is_instance());
       name = field.name();
       THR_Print("  - @%" Pd " %s\n", field.Offset(), name.ToCString());
     }
   }
 
   THR_Print("Mapping: ");
   for (int i = 0; i < mapping_.length(); i += 2) {
     THR_Print(" %" Pd "->%" Pd, mapping_.At(i), mapping_.At(i + 1));
   }
   THR_Print("\n");
 }
 
-
 void InstanceMorpher::Dump() const {
   LogBlock blocker;
   THR_Print("Morphing from ");
   DumpFormatFor(from_);
   THR_Print("To ");
   DumpFormatFor(to_);
   THR_Print("\n");
 }
 
-
 void InstanceMorpher::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ShapeChangeMapping");
   jsobj.AddProperty("class", to_);
   jsobj.AddProperty("instanceCount", before()->length());
   JSONArray map(&jsobj, "fieldOffsetMappings");
   for (int i = 0; i < mapping_.length(); i += 2) {
     JSONArray pair(&map);
     pair.AddValue(mapping_.At(i));
     pair.AddValue(mapping_.At(i + 1));
   }
 }
 
-
 void ReasonForCancelling::Report(IsolateReloadContext* context) {
   const Error& error = Error::Handle(ToError());
   context->ReportError(error);
 }
 
-
 RawError* ReasonForCancelling::ToError() {
   // By default create the error returned from ToString.
   const String& message = String::Handle(ToString());
   return LanguageError::New(message);
 }
 
-
 RawString* ReasonForCancelling::ToString() {
   UNREACHABLE();
   return NULL;
 }
 
-
 void ReasonForCancelling::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ReasonForCancelling");
   const String& message = String::Handle(ToString());
   jsobj.AddProperty("message", message.ToCString());
 }
 
-
 ClassReasonForCancelling::ClassReasonForCancelling(Zone* zone,
                                                    const Class& from,
                                                    const Class& to)
     : ReasonForCancelling(zone),
       from_(Class::ZoneHandle(zone, from.raw())),
       to_(Class::ZoneHandle(zone, to.raw())) {}
 
-
 void ClassReasonForCancelling::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ReasonForCancelling");
   jsobj.AddProperty("class", from_);
   const String& message = String::Handle(ToString());
   jsobj.AddProperty("message", message.ToCString());
 }
 
-
 RawError* IsolateReloadContext::error() const {
   ASSERT(reload_aborted());
   // Report the first error to the surroundings.
   return reasons_to_cancel_reload_.At(0)->ToError();
 }
 
-
 class ScriptUrlSetTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "ScriptUrlSetTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsString() || !b.IsString()) {
       return false;
     }
 
     return String::Cast(a).Equals(String::Cast(b));
   }
 
   static uword Hash(const Object& obj) { return String::Cast(obj).Hash(); }
 };
 
-
 class ClassMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "ClassMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsClass() || !b.IsClass()) {
       return false;
     }
     return IsolateReloadContext::IsSameClass(Class::Cast(a), Class::Cast(b));
   }
 
   static uword Hash(const Object& obj) {
     return String::HashRawSymbol(Class::Cast(obj).Name());
   }
 };
 
-
 class LibraryMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "LibraryMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsLibrary() || !b.IsLibrary()) {
       return false;
     }
     return IsolateReloadContext::IsSameLibrary(Library::Cast(a),
                                                Library::Cast(b));
   }
 
   static uword Hash(const Object& obj) { return Library::Cast(obj).UrlHash(); }
 };
 
-
 class BecomeMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "BecomeMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     return a.raw() == b.raw();
   }
 
   static uword Hash(const Object& obj) {
     if (obj.IsLibrary()) {
       return Library::Cast(obj).UrlHash();
     } else if (obj.IsClass()) {
       if (Class::Cast(obj).id() == kFreeListElement) {
         return 0;
       }
       return String::HashRawSymbol(Class::Cast(obj).Name());
     } else if (obj.IsField()) {
       return String::HashRawSymbol(Field::Cast(obj).name());
     } else if (obj.IsInstance()) {
       return Smi::Handle(Smi::RawCast(Instance::Cast(obj).HashCode())).Value();
     }
     return 0;
   }
 };
 
-
 bool IsolateReloadContext::IsSameField(const Field& a, const Field& b) {
   if (a.is_static() != b.is_static()) {
     return false;
   }
   const Class& a_cls = Class::Handle(a.Owner());
   const Class& b_cls = Class::Handle(b.Owner());
 
   if (!IsSameClass(a_cls, b_cls)) {
     return false;
   }
 
   const String& a_name = String::Handle(a.name());
   const String& b_name = String::Handle(b.name());
 
   return a_name.Equals(b_name);
 }
 
-
 bool IsolateReloadContext::IsSameClass(const Class& a, const Class& b) {
   if (a.is_patch() != b.is_patch()) {
     // TODO(johnmccutchan): Should we just check the class kind bits?
     return false;
   }
 
   // TODO(turnidge): We need to look at generic type arguments for
   // synthetic mixin classes.  Their names are not necessarily unique
   // currently.
   const String& a_name = String::Handle(a.Name());
   const String& b_name = String::Handle(b.Name());
 
   if (!a_name.Equals(b_name)) {
     return false;
   }
 
   const Library& a_lib = Library::Handle(a.library());
   const Library& b_lib = Library::Handle(b.library());
 
   if (a_lib.IsNull() || b_lib.IsNull()) {
     return a_lib.raw() == b_lib.raw();
   }
   return (a_lib.private_key() == b_lib.private_key());
 }
 
-
 bool IsolateReloadContext::IsSameLibrary(const Library& a_lib,
                                          const Library& b_lib) {
   const String& a_lib_url =
       String::Handle(a_lib.IsNull() ? String::null() : a_lib.url());
   const String& b_lib_url =
       String::Handle(b_lib.IsNull() ? String::null() : b_lib.url());
   return a_lib_url.Equals(b_lib_url);
 }
 
-
 IsolateReloadContext::IsolateReloadContext(Isolate* isolate, JSONStream* js)
     : zone_(Thread::Current()->zone()),
       start_time_micros_(OS::GetCurrentMonotonicMicros()),
       reload_timestamp_(OS::GetCurrentTimeMillis()),
       isolate_(isolate),
       reload_skipped_(false),
       reload_aborted_(false),
       reload_finalized_(false),
       js_(js),
       saved_num_cids_(-1),
@@ skipping 14 matching lines @@
       saved_root_library_(Library::null()),
       saved_libraries_(GrowableObjectArray::null()),
       root_url_prefix_(String::null()),
       old_root_url_prefix_(String::null()) {
   // NOTE: DO NOT ALLOCATE ANY RAW OBJECTS HERE. The IsolateReloadContext is not
   // associated with the isolate yet and if a GC is triggered here the raw
   // objects will not be properly accounted for.
   ASSERT(zone_ != NULL);
 }
 
-
 IsolateReloadContext::~IsolateReloadContext() {
   ASSERT(saved_class_table_ == NULL);
 }
 
-
 void IsolateReloadContext::ReportError(const Error& error) {
   if (FLAG_trace_reload) {
     THR_Print("ISO-RELOAD: Error: %s\n", error.ToErrorCString());
   }
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   service_event.set_reload_error(&error);
   Service::HandleEvent(&service_event);
 }
 
-
 void IsolateReloadContext::ReportSuccess() {
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   Service::HandleEvent(&service_event);
 }
 
-
 class Aborted : public ReasonForCancelling {
  public:
   Aborted(Zone* zone, const Error& error)
       : ReasonForCancelling(zone),
         error_(Error::ZoneHandle(zone, error.raw())) {}
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
   RawString* ToString() {
     return String::NewFormatted("%s", error_.ToErrorCString());
   }
 };
 
-
 static intptr_t CommonSuffixLength(const char* a, const char* b) {
   const intptr_t a_length = strlen(a);
   const intptr_t b_length = strlen(b);
   intptr_t a_cursor = a_length;
   intptr_t b_cursor = b_length;
 
   while ((a_cursor >= 0) && (b_cursor >= 0)) {
     if (a[a_cursor] != b[b_cursor]) {
       break;
     }
     a_cursor--;
     b_cursor--;
   }
 
   ASSERT((a_length - a_cursor) == (b_length - b_cursor));
   return (a_length - a_cursor);
 }
 
-
 // NOTE: This function returns *after* FinalizeLoading is called.
 void IsolateReloadContext::Reload(bool force_reload,
                                   const char* root_script_url,
                                   const char* packages_url_) {
   TIMELINE_SCOPE(Reload);
   Thread* thread = Thread::Current();
   ASSERT(isolate() == thread->isolate());
 
   // Grab root library before calling CheckpointBeforeReload.
   const Library& old_root_lib = Library::Handle(object_store()->root_library());
@@ skipping 111 matching lines @@
       UNREACHABLE();
     }
   }
 
   // Other errors (e.g. a parse error) are captured by the reload system.
   if (result.IsError()) {
     FinalizeFailedLoad(Error::Cast(result));
   }
 }
 
-
 void IsolateReloadContext::RegisterClass(const Class& new_cls) {
   const Class& old_cls = Class::Handle(OldClassOrNull(new_cls));
   if (old_cls.IsNull()) {
     I->class_table()->Register(new_cls);
 
     if (FLAG_identity_reload) {
       TIR_Print("Could not find replacement class for %s\n",
                 new_cls.ToCString());
       UNREACHABLE();
     }
 
     // New class maps to itself.
     AddClassMapping(new_cls, new_cls);
     return;
   }
   VTIR_Print("Registering class: %s\n", new_cls.ToCString());
   new_cls.set_id(old_cls.id());
   isolate()->class_table()->SetAt(old_cls.id(), new_cls.raw());
   if (!old_cls.is_enum_class()) {
     new_cls.CopyCanonicalConstants(old_cls);
   }
   new_cls.CopyCanonicalType(old_cls);
   AddBecomeMapping(old_cls, new_cls);
   AddClassMapping(new_cls, old_cls);
 }
 
-
 // FinalizeLoading will be called *before* Reload() returns but will not be
 // called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeLoading() {
   if (reload_skipped_) {
     return;
   }
   ASSERT(!reload_finalized_);
   BuildLibraryMapping();
   TIR_Print("---- LOAD SUCCEEDED\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
     isolate()->set_last_reload_timestamp(reload_timestamp_);
   } else {
     ReportReasonsForCancelling();
     Rollback();
   }
   // ValidateReload mutates the direct subclass information and does
   // not remove dead subclasses.  Rebuild the direct subclass
   // information from scratch.
   RebuildDirectSubclasses();
   CommonFinalizeTail();
 }
 
-
 // FinalizeFailedLoad will be called *before* Reload() returns and will only
 // be called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeFailedLoad(const Error& error) {
   TIR_Print("---- LOAD FAILED, ABORTING RELOAD\n");
   AddReasonForCancelling(new Aborted(zone_, error));
   ReportReasonsForCancelling();
   if (!reload_finalized_) {
     Rollback();
   }
   CommonFinalizeTail();
 }
 
-
 void IsolateReloadContext::CommonFinalizeTail() {
   ReportOnJSON(js_);
   reload_finalized_ = true;
 }
 
-
 void IsolateReloadContext::ReportOnJSON(JSONStream* stream) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "ReloadReport");
   jsobj.AddProperty("success", reload_skipped_ || !HasReasonsForCancelling());
   {
     JSONObject details(&jsobj, "details");
     if (reload_skipped_) {
       // Reload was skipped.
       const GrowableObjectArray& libs =
           GrowableObjectArray::Handle(object_store()->libraries());
@@ skipping 19 matching lines @@
       details.AddProperty("loadedLibraryCount", loaded_library_count);
       details.AddProperty("finalLibraryCount", final_library_count);
       JSONArray array(&jsobj, "shapeChangeMappings");
       for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
         instance_morphers_.At(i)->AppendTo(&array);
       }
     }
   }
 }
 
-
 void IsolateReloadContext::EnsuredUnoptimizedCodeForStack() {
   TIMELINE_SCOPE(EnsuredUnoptimizedCodeForStack);
   StackFrameIterator it(StackFrameIterator::kDontValidateFrames,
                         Thread::Current(),
                         StackFrameIterator::kNoCrossThreadIteration);
 
   Function& func = Function::Handle();
   while (it.HasNextFrame()) {
     StackFrame* frame = it.NextFrame();
     if (frame->IsDartFrame()) {
       func = frame->LookupDartFunction();
       ASSERT(!func.IsNull());
       func.EnsureHasCompiledUnoptimizedCode();
     }
   }
 }
 
-
 void IsolateReloadContext::DeoptimizeDependentCode() {
   TIMELINE_SCOPE(DeoptimizeDependentCode);
   ClassTable* class_table = I->class_table();
 
   const intptr_t bottom = Dart::vm_isolate()->class_table()->NumCids();
   const intptr_t top = I->class_table()->NumCids();
   Class& cls = Class::Handle();
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
   for (intptr_t cls_idx = bottom; cls_idx < top; cls_idx++) {
@@ skipping 14 matching lines @@
     for (intptr_t field_idx = 0; field_idx < fields.Length(); field_idx++) {
       field = Field::RawCast(fields.At(field_idx));
       ASSERT(!field.IsNull());
       field.DeoptimizeDependentCode();
     }
   }
 
   // TODO(johnmccutchan): Also call LibraryPrefix::InvalidateDependentCode.
 }
 
-
 void IsolateReloadContext::CheckpointClasses() {
   TIMELINE_SCOPE(CheckpointClasses);
   TIR_Print("---- CHECKPOINTING CLASSES\n");
   // Checkpoint classes before a reload. We need to copy the following:
   // 1) The size of the class table.
   // 2) The class table itself.
   // For efficiency, we build a set of classes before the reload. This set
   // is used to pair new classes with old classes.
 
   ClassTable* class_table = I->class_table();
@@ skipping 20 matching lines @@
       // No class at this index, mark it as NULL.
       local_saved_class_table[i] = NULL;
     }
   }
   old_classes_set_storage_ = old_classes_set.Release().raw();
   // Assigning the field must be done after saving the class table.
   saved_class_table_ = local_saved_class_table;
   TIR_Print("---- System had %" Pd " classes\n", saved_num_cids_);
 }
 
-
 Dart_FileModifiedCallback IsolateReloadContext::file_modified_callback_ = NULL;
 
-
 bool IsolateReloadContext::ScriptModifiedSince(const Script& script,
                                                int64_t since) {
   if (file_modified_callback_ == NULL) {
     return true;
   }
   // We use the resolved url to determine if the script has been modified.
   const String& url = String::Handle(script.resolved_url());
   const char* url_chars = url.ToCString();
   return (*file_modified_callback_)(url_chars, since);
 }
 
-
 static void PropagateLibraryModified(
     const ZoneGrowableArray<ZoneGrowableArray<intptr_t>*>* imported_by,
     intptr_t lib_index,
     BitVector* modified_libs) {
   ZoneGrowableArray<intptr_t>* dep_libs = (*imported_by)[lib_index];
   for (intptr_t i = 0; i < dep_libs->length(); i++) {
     intptr_t dep_lib_index = (*dep_libs)[i];
     if (!modified_libs->Contains(dep_lib_index)) {
       modified_libs->Add(dep_lib_index);
       PropagateLibraryModified(imported_by, dep_lib_index, modified_libs);
     }
   }
 }
 
-
 BitVector* IsolateReloadContext::FindModifiedLibraries(bool force_reload) {
   Thread* thread = Thread::Current();
   int64_t last_reload = I->last_reload_timestamp();
 
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
   Library& lib = Library::Handle();
   Array& scripts = Array::Handle();
   Script& script = Script::Handle();
   intptr_t num_libs = libs.Length();
@@ skipping 75 matching lines @@
         modified_libs->Add(lib_idx);
         PropagateLibraryModified(imported_by, lib_idx, modified_libs);
         break;
       }
     }
   }
 
   return modified_libs;
 }
 
-
 void IsolateReloadContext::CheckpointLibraries() {
   TIMELINE_SCOPE(CheckpointLibraries);
   TIR_Print("---- CHECKPOINTING LIBRARIES\n");
   // Save the root library in case we abort the reload.
   const Library& root_lib = Library::Handle(object_store()->root_library());
   set_saved_root_library(root_lib);
 
   // Save the old libraries array in case we abort the reload.
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
@@ skipping 24 matching lines @@
   }
   modified_libs_ = NULL;  // Renumbering the libraries has invalidated this.
   old_libraries_set_storage_ = old_libraries_set.Release().raw();
 
   // Reset the registered libraries to the filtered array.
   Library::RegisterLibraries(Thread::Current(), new_libs);
   // Reset the root library to null.
   object_store()->set_root_library(Library::Handle());
 }
 
-
 // While reloading everything we do must be reversible so that we can abort
 // safely if the reload fails. This function stashes things to the side and
 // prepares the isolate for the reload attempt.
 void IsolateReloadContext::Checkpoint() {
   TIMELINE_SCOPE(Checkpoint);
   CheckpointClasses();
   CheckpointLibraries();
 }
 
-
 void IsolateReloadContext::RollbackClasses() {
   TIR_Print("---- ROLLING BACK CLASS TABLE\n");
   ASSERT(saved_num_cids_ > 0);
   ASSERT(saved_class_table_ != NULL);
   ClassTable* class_table = I->class_table();
   class_table->SetNumCids(saved_num_cids_);
   // Overwrite classes in class table with the saved classes.
   for (intptr_t i = 0; i < saved_num_cids_; i++) {
     if (class_table->IsValidIndex(i)) {
       class_table->SetAt(i, saved_class_table_[i]);
     }
   }
 
   RawClass** local_saved_class_table = saved_class_table_;
   saved_class_table_ = NULL;
   // Can't free this table immediately as another thread (e.g., the sweeper) may
   // be suspended between loading the table pointer and loading the table
   // element. Table will be freed at the next major GC or isolate shutdown.
   class_table->AddOldTable(local_saved_class_table);
 }
 
-
 void IsolateReloadContext::RollbackLibraries() {
   TIR_Print("---- ROLLING BACK LIBRARY CHANGES\n");
   Thread* thread = Thread::Current();
   Library& lib = Library::Handle();
   GrowableObjectArray& saved_libs =
       GrowableObjectArray::Handle(Z, saved_libraries());
   if (!saved_libs.IsNull()) {
     for (intptr_t i = 0; i < saved_libs.Length(); i++) {
       lib = Library::RawCast(saved_libs.At(i));
       // Restore indexes that were modified in CheckpointLibraries.
       lib.set_index(i);
     }
 
     // Reset the registered libraries to the filtered array.
     Library::RegisterLibraries(thread, saved_libs);
   }
 
   Library& saved_root_lib = Library::Handle(Z, saved_root_library());
   if (!saved_root_lib.IsNull()) {
     object_store()->set_root_library(saved_root_lib);
   }
 
   set_saved_root_library(Library::Handle());
   set_saved_libraries(GrowableObjectArray::Handle());
 }
 
-
 void IsolateReloadContext::Rollback() {
   TIR_Print("---- ROLLING BACK");
   RollbackClasses();
   RollbackLibraries();
 }
 
-
 #ifdef DEBUG
 void IsolateReloadContext::VerifyMaps() {
   TIMELINE_SCOPE(VerifyMaps);
   Class& cls = Class::Handle();
   Class& new_cls = Class::Handle();
   Class& cls2 = Class::Handle();
 
   // Verify that two old classes aren't both mapped to the same new
   // class. This could happen is the IsSameClass function is broken.
   UnorderedHashMap<ClassMapTraits> class_map(class_map_storage_);
@@ skipping 16 matching lines @@
       }
       bool update = reverse_class_map.UpdateOrInsert(cls, new_cls);
       ASSERT(!update);
     }
   }
   class_map.Release();
   reverse_class_map.Release();
 }
 #endif
 
-
 void IsolateReloadContext::Commit() {
   TIMELINE_SCOPE(Commit);
   TIR_Print("---- COMMITTING RELOAD\n");
 
   // Note that the object heap contains before and after instances
   // used for morphing. It is therefore important that morphing takes
   // place prior to any heap walking.
   // So please keep this code at the top of Commit().
   if (HasInstanceMorphers()) {
     // Perform shape shifting of instances if necessary.
@@ skipping 147 matching lines @@
 #ifdef DEBUG
   // Verify that all canonical instances are correctly setup in the
   // corresponding canonical tables.
   Thread* thread = Thread::Current();
   I->heap()->CollectAllGarbage();
   VerifyCanonicalVisitor check_canonical(thread);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // DEBUG
 }
 
-
 void IsolateReloadContext::RehashConstants() {
   TIMELINE_SCOPE(RehashConstants);
   ClassTable* class_table = I->class_table();
   Class& cls = Class::Handle(zone_);
   const intptr_t top = class_table->NumCids();
   for (intptr_t cid = kInstanceCid; cid < top; cid++) {
     if (!class_table->IsValidIndex(cid) || !class_table->HasValidClassAt(cid)) {
       // Skip invalid classes.
       continue;
     }
     if (RawObject::IsNumberClassId(cid) || RawObject::IsStringClassId(cid)) {
       // Skip classes that cannot be affected by the 'become' operation.
       continue;
     }
     // Rehash constants.
     cls = class_table->At(cid);
     VTIR_Print("Rehashing constants in class `%s`\n", cls.ToCString());
     cls.RehashConstants(zone_);
   }
 }
 
-
 bool IsolateReloadContext::IsDirty(const Library& lib) {
   const intptr_t index = lib.index();
   if (index == static_cast<classid_t>(-1)) {
     // Treat deleted libraries as dirty.
     return true;
   }
   ASSERT((index >= 0) && (index < library_infos_.length()));
   return library_infos_[index].dirty;
 }
 
-
 void IsolateReloadContext::PostCommit() {
   TIMELINE_SCOPE(PostCommit);
   set_saved_root_library(Library::Handle());
   set_saved_libraries(GrowableObjectArray::Handle());
   InvalidateWorld();
   TIR_Print("---- DONE COMMIT\n");
 }
 
-
 void IsolateReloadContext::AddReasonForCancelling(ReasonForCancelling* reason) {
   reload_aborted_ = true;
   reasons_to_cancel_reload_.Add(reason);
 }
 
-
 void IsolateReloadContext::AddInstanceMorpher(InstanceMorpher* morpher) {
   instance_morphers_.Add(morpher);
   cid_mapper_.Insert(morpher);
 }
 
-
 void IsolateReloadContext::ReportReasonsForCancelling() {
   ASSERT(FLAG_reload_force_rollback || HasReasonsForCancelling());
   for (int i = 0; i < reasons_to_cancel_reload_.length(); i++) {
     reasons_to_cancel_reload_.At(i)->Report(this);
   }
 }
 
-
 // The ObjectLocator is used for collecting instances that
 // needs to be morphed.
 class ObjectLocator : public ObjectVisitor {
  public:
   explicit ObjectLocator(IsolateReloadContext* context)
       : context_(context), count_(0) {}
 
   void VisitObject(RawObject* obj) {
     InstanceMorpher* morpher =
         context_->cid_mapper_.LookupValue(obj->GetClassId());
     if (morpher != NULL) {
       morpher->AddObject(obj);
       count_++;
     }
   }
 
   // Return the number of located objects for morphing.
   intptr_t count() { return count_; }
 
  private:
   IsolateReloadContext* context_;
   intptr_t count_;
 };
 
-
 void IsolateReloadContext::MorphInstances() {
   TIMELINE_SCOPE(MorphInstances);
   ASSERT(HasInstanceMorphers());
   if (FLAG_trace_reload) {
     LogBlock blocker;
     TIR_Print("MorphInstance: \n");
     for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
       instance_morphers_.At(i)->Dump();
     }
   }
@@ skipping 33 matching lines @@
   }
 
   // This is important: The saved class table (describing before objects)
   // must be zapped to prevent the forwarding in GetClassForHeapWalkAt.
   // Instance will from now be described by the isolate's class table.
   free(saved_class_table_);
   saved_class_table_ = NULL;
   Become::ElementsForwardIdentity(before, after);
 }
 
-
 void IsolateReloadContext::RunNewFieldInitializers() {
   // Run new field initializers on all instances.
   for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
     instance_morphers_.At(i)->RunNewFieldInitializers();
   }
 }
 
-
 bool IsolateReloadContext::ValidateReload() {
   TIMELINE_SCOPE(ValidateReload);
   if (reload_aborted()) return false;
 
   TIR_Print("---- VALIDATING RELOAD\n");
 
   // Validate libraries.
   {
     ASSERT(library_map_storage_ != Array::null());
     UnorderedHashMap<LibraryMapTraits> map(library_map_storage_);
@@ skipping 25 matching lines @@
       if (new_cls.raw() != cls.raw()) {
         cls.CheckReload(new_cls, this);
       }
     }
     map.Release();
   }
 
   return !FLAG_reload_force_rollback && !HasReasonsForCancelling();
 }
 
-
 RawClass* IsolateReloadContext::FindOriginalClass(const Class& cls) {
   return MappedClass(cls);
 }
 
-
 RawClass* IsolateReloadContext::GetClassForHeapWalkAt(intptr_t cid) {
   RawClass** class_table = AtomicOperations::LoadRelaxed(&saved_class_table_);
   if (class_table != NULL) {
     ASSERT(cid > 0);
     ASSERT(cid < saved_num_cids_);
     return class_table[cid];
   } else {
     return isolate_->class_table()->At(cid);
   }
 }
 
-
 RawLibrary* IsolateReloadContext::saved_root_library() const {
   return saved_root_library_;
 }
 
-
 void IsolateReloadContext::set_saved_root_library(const Library& value) {
   saved_root_library_ = value.raw();
 }
 
-
 RawGrowableObjectArray* IsolateReloadContext::saved_libraries() const {
   return saved_libraries_;
 }
 
-
 void IsolateReloadContext::set_saved_libraries(
     const GrowableObjectArray& value) {
   saved_libraries_ = value.raw();
 }
 
-
 void IsolateReloadContext::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointers(from(), to());
   if (saved_class_table_ != NULL) {
     visitor->VisitPointers(
         reinterpret_cast<RawObject**>(&saved_class_table_[0]), saved_num_cids_);
   }
 }
 
-
 ObjectStore* IsolateReloadContext::object_store() {
   return isolate_->object_store();
 }
 
-
 void IsolateReloadContext::ResetUnoptimizedICsOnStack() {
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   Zone* zone = stack_zone.GetZone();
 
   Code& code = Code::Handle(zone);
   Function& function = Function::Handle(zone);
   DartFrameIterator iterator(thread,
                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL) {
     code = frame->LookupDartCode();
     if (code.is_optimized()) {
       // If this code is optimized, we need to reset the ICs in the
       // corresponding unoptimized code, which will be executed when the stack
       // unwinds to the optimized code.
       function = code.function();
       code = function.unoptimized_code();
       ASSERT(!code.IsNull());
       code.ResetICDatas(zone);
     } else {
       code.ResetICDatas(zone);
     }
     frame = iterator.NextFrame();
   }
 }
 
-
 void IsolateReloadContext::ResetMegamorphicCaches() {
   object_store()->set_megamorphic_cache_table(GrowableObjectArray::Handle());
   // Since any current optimized code will not make any more calls, it may be
   // better to clear the table instead of clearing each of the caches, allow
   // the current megamorphic caches get GC'd and any new optimized code allocate
   // new ones.
 }
 
-
 class MarkFunctionsForRecompilation : public ObjectVisitor {
  public:
   MarkFunctionsForRecompilation(Isolate* isolate,
                                 IsolateReloadContext* reload_context,
                                 Zone* zone)
       : ObjectVisitor(),
         handle_(Object::Handle(zone)),
         owning_class_(Class::Handle(zone)),
         owning_lib_(Library::Handle(zone)),
         code_(Code::Handle(zone)),
@@ skipping 64 matching lines @@
   }
 
   Object& handle_;
   Class& owning_class_;
   Library& owning_lib_;
   Code& code_;
   IsolateReloadContext* reload_context_;
   Zone* zone_;
 };
 
-
 void IsolateReloadContext::MarkAllFunctionsForRecompilation() {
   TIMELINE_SCOPE(MarkAllFunctionsForRecompilation);
   TIR_Print("---- MARKING ALL FUNCTIONS FOR RECOMPILATION\n");
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   Zone* zone = stack_zone.GetZone();
   NoSafepointScope no_safepoint;
   HeapIterationScope heap_iteration_scope;
   MarkFunctionsForRecompilation visitor(isolate_, this, zone);
   isolate_->heap()->VisitObjects(&visitor);
 }
 
-
 void IsolateReloadContext::InvalidateWorld() {
   TIR_Print("---- INVALIDATING WORLD\n");
   ResetMegamorphicCaches();
   DeoptimizeFunctionsOnStack();
   ResetUnoptimizedICsOnStack();
   MarkAllFunctionsForRecompilation();
 }
 
-
 RawClass* IsolateReloadContext::MappedClass(const Class& replacement_or_new) {
   UnorderedHashMap<ClassMapTraits> map(class_map_storage_);
   Class& cls = Class::Handle();
   cls ^= map.GetOrNull(replacement_or_new);
   // No need to update storage address because no mutation occurred.
   map.Release();
   return cls.raw();
 }
 
-
 RawLibrary* IsolateReloadContext::MappedLibrary(
     const Library& replacement_or_new) {
   return Library::null();
 }
 
-
 RawClass* IsolateReloadContext::OldClassOrNull(
     const Class& replacement_or_new) {
   UnorderedHashSet<ClassMapTraits> old_classes_set(old_classes_set_storage_);
   Class& cls = Class::Handle();
   cls ^= old_classes_set.GetOrNull(replacement_or_new);
   old_classes_set_storage_ = old_classes_set.Release().raw();
   return cls.raw();
 }
 
-
 RawString* IsolateReloadContext::FindLibraryPrivateKey(
     const Library& replacement_or_new) {
   const Library& old = Library::Handle(OldLibraryOrNull(replacement_or_new));
   if (old.IsNull()) {
     return String::null();
   }
 #if defined(DEBUG)
   VTIR_Print("`%s` is getting `%s`'s private key.\n",
              String::Handle(replacement_or_new.url()).ToCString(),
              String::Handle(old.url()).ToCString());
 #endif
   return old.private_key();
 }
 
-
 RawLibrary* IsolateReloadContext::OldLibraryOrNull(
     const Library& replacement_or_new) {
   UnorderedHashSet<LibraryMapTraits> old_libraries_set(
       old_libraries_set_storage_);
   Library& lib = Library::Handle();
   lib ^= old_libraries_set.GetOrNull(replacement_or_new);
   old_libraries_set.Release();
   if (lib.IsNull() && (root_url_prefix_ != String::null()) &&
       (old_root_url_prefix_ != String::null())) {
     return OldLibraryOrNullBaseMoved(replacement_or_new);
   }
   return lib.raw();
 }
 
-
 // Attempt to find the pair to |replacement_or_new| with the knowledge that
 // the base url prefix has moved.
 RawLibrary* IsolateReloadContext::OldLibraryOrNullBaseMoved(
     const Library& replacement_or_new) {
   const String& url_prefix = String::Handle(root_url_prefix_);
   const String& old_url_prefix = String::Handle(old_root_url_prefix_);
   const intptr_t prefix_length = url_prefix.Length();
   const intptr_t old_prefix_length = old_url_prefix.Length();
   const String& new_url = String::Handle(replacement_or_new.url());
   const String& suffix =
@@ skipping 19 matching lines @@
     }
     if (old_suffix.Equals(suffix)) {
       TIR_Print("`%s` is moving to `%s`\n", old_url.ToCString(),
                 new_url.ToCString());
       return old.raw();
     }
   }
   return Library::null();
 }
 
-
 void IsolateReloadContext::BuildLibraryMapping() {
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
 
   Library& replacement_or_new = Library::Handle();
   Library& old = Library::Handle();
   for (intptr_t i = num_saved_libs_; i < libs.Length(); i++) {
     replacement_or_new = Library::RawCast(libs.At(i));
     old ^= OldLibraryOrNull(replacement_or_new);
     if (old.IsNull()) {
       if (FLAG_identity_reload) {
         TIR_Print("Could not find original library for %s\n",
                   replacement_or_new.ToCString());
         UNREACHABLE();
       }
       // New library.
       AddLibraryMapping(replacement_or_new, replacement_or_new);
     } else {
       ASSERT(!replacement_or_new.is_dart_scheme());
       // Replaced class.
       AddLibraryMapping(replacement_or_new, old);
 
       AddBecomeMapping(old, replacement_or_new);
     }
   }
 }
 
-
 void IsolateReloadContext::AddClassMapping(const Class& replacement_or_new,
                                            const Class& original) {
   UnorderedHashMap<ClassMapTraits> map(class_map_storage_);
   bool update = map.UpdateOrInsert(replacement_or_new, original);
   ASSERT(!update);
   // The storage given to the map may have been reallocated, remember the new
   // address.
   class_map_storage_ = map.Release().raw();
 }
 
-
 void IsolateReloadContext::AddLibraryMapping(const Library& replacement_or_new,
                                              const Library& original) {
   UnorderedHashMap<LibraryMapTraits> map(library_map_storage_);
   bool update = map.UpdateOrInsert(replacement_or_new, original);
   ASSERT(!update);
   // The storage given to the map may have been reallocated, remember the new
   // address.
   library_map_storage_ = map.Release().raw();
 }
 
-
 void IsolateReloadContext::AddStaticFieldMapping(const Field& old_field,
                                                  const Field& new_field) {
   ASSERT(old_field.is_static());
   ASSERT(new_field.is_static());
 
   AddBecomeMapping(old_field, new_field);
 }
 
-
 void IsolateReloadContext::AddBecomeMapping(const Object& old,
                                             const Object& neu) {
   ASSERT(become_map_storage_ != Array::null());
   UnorderedHashMap<BecomeMapTraits> become_map(become_map_storage_);
   bool update = become_map.UpdateOrInsert(old, neu);
   ASSERT(!update);
   become_map_storage_ = become_map.Release().raw();
 }
 
-
 void IsolateReloadContext::AddEnumBecomeMapping(const Object& old,
                                                 const Object& neu) {
   const GrowableObjectArray& become_enum_mappings =
       GrowableObjectArray::Handle(become_enum_mappings_);
   become_enum_mappings.Add(old);
   become_enum_mappings.Add(neu);
   ASSERT((become_enum_mappings.Length() % 2) == 0);
 }
 
-
 void IsolateReloadContext::RebuildDirectSubclasses() {
   ClassTable* class_table = I->class_table();
   intptr_t num_cids = class_table->NumCids();
 
   // Clear the direct subclasses for all classes.
   Class& cls = Class::Handle();
   GrowableObjectArray& subclasses = GrowableObjectArray::Handle();
   for (intptr_t i = 1; i < num_cids; i++) {
     if (class_table->HasValidClassAt(i)) {
       cls = class_table->At(i);
@@ skipping 16 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart