Rework how enums are implemented and reloaded

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/code_generator.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/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");
+DEFINE_FLAG(bool, trace_reload_verbose, false,
+            "trace isolate reloading verbose");
 DEFINE_FLAG(bool, identity_reload, false, "Enable checks for identity reload.");
 DEFINE_FLAG(int, reload_every, 0, "Reload every N stack overflow checks.");
 DEFINE_FLAG(bool, reload_every_optimized, true, "Only from optimized code.");
 DEFINE_FLAG(bool, reload_every_back_off, false,
             "Double the --reload-every value after each reload.");
 DEFINE_FLAG(bool, check_reloaded, false,
             "Assert that an isolate has reloaded at least once.")
 #ifndef PRODUCT
 
 #define I (isolate())
@@ skipping 73 matching lines @@
   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;
   }
@@ skipping 51 matching lines @@
       saved_num_cids_(-1),
       saved_class_table_(NULL),
       num_saved_libs_(-1),
       script_uri_(String::null()),
       error_(Error::null()),
       old_classes_set_storage_(Array::null()),
       class_map_storage_(Array::null()),
       old_libraries_set_storage_(Array::null()),
       library_map_storage_(Array::null()),
       become_map_storage_(Array::null()),
+      become_enum_mappings_(GrowableObjectArray::null()),
       saved_root_library_(Library::null()),
       saved_libraries_(GrowableObjectArray::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.
 }
 
 
 IsolateReloadContext::~IsolateReloadContext() {
 }
@@ skipping 36 matching lines @@
   old_classes_set_storage_ =
       HashTables::New<UnorderedHashSet<ClassMapTraits> >(4);
   class_map_storage_ =
       HashTables::New<UnorderedHashMap<ClassMapTraits> >(4);
   old_libraries_set_storage_ =
       HashTables::New<UnorderedHashSet<LibraryMapTraits> >(4);
   library_map_storage_ =
       HashTables::New<UnorderedHashMap<LibraryMapTraits> >(4);
   become_map_storage_ =
       HashTables::New<UnorderedHashMap<BecomeMapTraits> >(4);
+  // Keep a separate array for enum mappings to avoid having to invoke
+  // hashCode on the instances.
+  become_enum_mappings_ = GrowableObjectArray::New(Heap::kOld);
 
   // Disable the background compiler while we are performing the reload.
   BackgroundCompiler::Disable();
 
   if (FLAG_write_protect_code) {
     // Disable code page write protection while we are reloading.
     I->heap()->WriteProtectCode(false);
   }
 
   // Ensure all functions on the stack have unoptimized code.
@@ skipping 338 matching lines @@
     {
       UnorderedHashMap<ClassMapTraits>::Iterator it(&class_map);
       while (it.MoveNext()) {
         const intptr_t entry = it.Current();
         new_cls = Class::RawCast(class_map.GetKey(entry));
         cls = Class::RawCast(class_map.GetPayload(entry, 0));
         if (new_cls.raw() != cls.raw()) {
           ASSERT(new_cls.is_enum_class() == cls.is_enum_class());
           if (new_cls.is_enum_class() && new_cls.is_finalized()) {
             new_cls.ReplaceEnum(cls);
+          } else {
+            new_cls.CopyStaticFieldValues(cls);
           }
-          new_cls.CopyStaticFieldValues(cls);
           cls.PatchFieldsAndFunctions();
         }
       }
     }
 
     class_map.Release();
   }
 
   // Copy over certain properties of libraries, e.g. is the library
   // debuggable?
@@ skipping 22 matching lines @@
   }
 
   {
     TIMELINE_SCOPE(UpdateLibrariesArray);
     // Update the libraries array.
     Library& lib = Library::Handle();
     const GrowableObjectArray& libs = GrowableObjectArray::Handle(
         I->object_store()->libraries());
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib = Library::RawCast(libs.At(i));
-      TIR_Print("Lib '%s' at index %" Pd "\n", lib.ToCString(), i);
+      VTIR_Print("Lib '%s' at index %" Pd "\n", lib.ToCString(), i);
       lib.set_index(i);
     }
 
     // Initialize library side table.
     library_infos_.SetLength(libs.Length());
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib = Library::RawCast(libs.At(i));
       // Mark the library dirty if it comes after the libraries we saved.
       library_infos_[i].dirty = i >= num_saved_libs_;
     }
   }
 
   {
+    const GrowableObjectArray& become_enum_mappings =
+        GrowableObjectArray::Handle(become_enum_mappings_);
     UnorderedHashMap<BecomeMapTraits> become_map(become_map_storage_);
-    intptr_t replacement_count = become_map.NumOccupied();
+    intptr_t replacement_count = become_map.NumOccupied() +
+                                 become_enum_mappings.Length() / 2;
     const Array& before =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
     const Array& after =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
     Object& obj = Object::Handle();
     intptr_t replacement_index = 0;
     UnorderedHashMap<BecomeMapTraits>::Iterator it(&become_map);
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       obj = become_map.GetKey(entry);
       before.SetAt(replacement_index, obj);
       obj = become_map.GetPayload(entry, 0);
       after.SetAt(replacement_index, obj);
       replacement_index++;
     }
+    for (intptr_t i = 0; i < become_enum_mappings.Length(); i += 2) {
+      obj = become_enum_mappings.At(i);
+      before.SetAt(replacement_index, obj);
+      obj = become_enum_mappings.At(i + 1);
+      after.SetAt(replacement_index, obj);
+      replacement_index++;
+    }
     ASSERT(replacement_index == replacement_count);
     become_map.Release();
 
     Become::ElementsForwardIdentity(before, after);
   }
 
   if (FLAG_identity_reload) {
     if (saved_num_cids_ != I->class_table()->NumCids()) {
       TIR_Print("Identity reload failed! B#C=%" Pd " A#C=%" Pd "\n",
                 saved_num_cids_,
@@ skipping 372 matching lines @@
 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