Sort class IDs before training AppJIT snapshots

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
+#include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
 #include "vm/dart_entry.h"
 #include "vm/disassembler.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 398 matching lines @@
     StackZone stack_zone(T);
     zone_ = stack_zone.GetZone();
 
     {
       HANDLESCOPE(T);
       // Make sure class hierarchy is stable before compilation so that CHA
       // can be used. Also ensures lookup of entry points won't miss functions
       // because their class hasn't been finalized yet.
       FinalizeAllClasses();
 
-      SortClasses();
+      ClassFinalizer::SortClasses();
       TypeRangeCache trc(this, T, I->class_table()->NumCids());
       VerifyJITFeedback();
 
       // Precompile static initializers to compute result type information.
       PrecompileStaticInitializers();
 
       // Precompile constructors to compute type information for final fields.
-      ClearAllCode();
+      ClassFinalizer::ClearAllCode();
       PrecompileConstructors();
 
       for (intptr_t round = 0; round < FLAG_precompiler_rounds; round++) {
         if (FLAG_trace_precompiler) {
           THR_Print("Precompiler round %" Pd "\n", round);
         }
 
         if (round > 0) {
           ResetPrecompilerState();
         }
 
         // TODO(rmacnak): We should be able to do a more thorough job and drop
         // some
         //  - implicit static closures
         //  - field initializers
         //  - invoke-field-dispatchers
         //  - method-extractors
         // that are needed in early iterations but optimized away in later
         // iterations.
-        ClearAllCode();
+        ClassFinalizer::ClearAllCode();
 
         CollectDynamicFunctionNames();
 
         // Start with the allocations and invocations that happen from C++.
         AddRoots(embedder_entry_points);
 
         // Compile newly found targets and add their callees until we reach a
         // fixed point.
         Iterate();
       }
@@ skipping 143 matching lines @@
     current->field_->set_is_nullable(cid == kNullCid || cid == kDynamicCid);
     if (FLAG_trace_precompiler) {
       THR_Print(
           "Field %s <- Type %s\n", current->field_->ToCString(),
           Class::Handle(T->isolate()->class_table()->At(cid)).ToCString());
     }
   }
 }
 
 
-void Precompiler::ClearAllCode() {
-  class ClearCodeFunctionVisitor : public FunctionVisitor {
-    void Visit(const Function& function) {
-      function.ClearCode();
-      function.ClearICDataArray();
-    }
-  };
-  ClearCodeFunctionVisitor function_visitor;
-  ProgramVisitor::VisitFunctions(&function_visitor);
-
-  class ClearCodeClassVisitor : public ClassVisitor {
-    void Visit(const Class& cls) { cls.DisableAllocationStub(); }
-  };
-  ClearCodeClassVisitor class_visitor;
-  ProgramVisitor::VisitClasses(&class_visitor);
-}
-
-
 void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
   // Note that <rootlibrary>.main is not a root. The appropriate main will be
   // discovered through _getMainClosure.
 
   AddSelector(Symbols::NoSuchMethod());
 
   AddSelector(Symbols::Call());  // For speed, not correctness.
 
   // Allocated from C++.
   Class& cls = Class::Handle(Z);
@@ skipping 1886 matching lines @@
       error_ = cls.EnsureIsFinalized(T);
       if (!error_.IsNull()) {
         Jump(error_);
       }
     }
   }
   I->set_all_classes_finalized(true);
 }
 
 
-void Precompiler::SortClasses() {
-  ClassTable* table = I->class_table();
-  intptr_t num_cids = table->NumCids();
-  intptr_t* old_to_new_cid = new intptr_t[num_cids];
-  for (intptr_t cid = 0; cid < kNumPredefinedCids; cid++) {
-    old_to_new_cid[cid] = cid;  // The predefined classes cannot change cids.
-  }
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
-    old_to_new_cid[cid] = -1;
-  }
-
-  intptr_t next_new_cid = kNumPredefinedCids;
-  GrowableArray<intptr_t> dfs_stack;
-  Class& cls = Class::Handle(Z);
-  GrowableObjectArray& subclasses = GrowableObjectArray::Handle(Z);
-
-  // Object doesn't use its subclasses list.
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
-    if (!table->HasValidClassAt(cid)) {
-      continue;
-    }
-    cls = table->At(cid);
-    if (cls.is_patch()) {
-      continue;
-    }
-    if (cls.SuperClass() == I->object_store()->object_class()) {
-      dfs_stack.Add(cid);
-    }
-  }
-
-  while (dfs_stack.length() > 0) {
-    intptr_t cid = dfs_stack.RemoveLast();
-    ASSERT(table->HasValidClassAt(cid));
-    cls = table->At(cid);
-    ASSERT(!cls.IsNull());
-    if (old_to_new_cid[cid] == -1) {
-      old_to_new_cid[cid] = next_new_cid++;
-      if (FLAG_trace_precompiler) {
-        THR_Print("%" Pd ": %s, was %" Pd "\n", old_to_new_cid[cid],
-                  cls.ToCString(), cid);
-      }
-    }
-    subclasses = cls.direct_subclasses();
-    if (!subclasses.IsNull()) {
-      for (intptr_t i = 0; i < subclasses.Length(); i++) {
-        cls ^= subclasses.At(i);
-        ASSERT(!cls.IsNull());
-        dfs_stack.Add(cls.id());
-      }
-    }
-  }
-
-  // Top-level classes, typedefs, patch classes, etc.
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
-    if (old_to_new_cid[cid] == -1) {
-      old_to_new_cid[cid] = next_new_cid++;
-      if (FLAG_trace_precompiler && table->HasValidClassAt(cid)) {
-        cls = table->At(cid);
-        THR_Print("%" Pd ": %s, was %" Pd "\n", old_to_new_cid[cid],
-                  cls.ToCString(), cid);
-      }
-    }
-  }
-  ASSERT(next_new_cid == num_cids);
-
-  RemapClassIds(old_to_new_cid);
-  delete[] old_to_new_cid;
-  RehashTypes();  // Types use cid's as part of their hashes.
-}
-
-
-class CidRewriteVisitor : public ObjectVisitor {
- public:
-  explicit CidRewriteVisitor(intptr_t* old_to_new_cids)
-      : old_to_new_cids_(old_to_new_cids) {}
-
-  intptr_t Map(intptr_t cid) {
-    ASSERT(cid != -1);
-    return old_to_new_cids_[cid];
-  }
-
-  void VisitObject(RawObject* obj) {
-    if (obj->IsClass()) {
-      RawClass* cls = Class::RawCast(obj);
-      cls->ptr()->id_ = Map(cls->ptr()->id_);
-    } else if (obj->IsField()) {
-      RawField* field = Field::RawCast(obj);
-      field->ptr()->guarded_cid_ = Map(field->ptr()->guarded_cid_);
-      field->ptr()->is_nullable_ = Map(field->ptr()->is_nullable_);
-    } else if (obj->IsTypeParameter()) {
-      RawTypeParameter* param = TypeParameter::RawCast(obj);
-      param->ptr()->parameterized_class_id_ =
-          Map(param->ptr()->parameterized_class_id_);
-    } else if (obj->IsType()) {
-      RawType* type = Type::RawCast(obj);
-      RawObject* id = type->ptr()->type_class_id_;
-      if (!id->IsHeapObject()) {
-        type->ptr()->type_class_id_ =
-            Smi::New(Map(Smi::Value(Smi::RawCast(id))));
-      }
-    } else {
-      intptr_t old_cid = obj->GetClassId();
-      intptr_t new_cid = Map(old_cid);
-      if (old_cid != new_cid) {
-        // Don't touch objects that are unchanged. In particular, Instructions,
-        // which are write-protected.
-        obj->SetClassId(new_cid);
-      }
-    }
-  }
-
- private:
-  intptr_t* old_to_new_cids_;
-};
-
-
-void Precompiler::RemapClassIds(intptr_t* old_to_new_cid) {
-  // Code, ICData, allocation stubs have now-invalid cids.
-  ClearAllCode();
-
-  {
-    HeapIterationScope his;
-
-    // Update the class table. Do it before rewriting cids in headers, as the
-    // heap walkers load an object's size *after* calling the visitor.
-    I->class_table()->Remap(old_to_new_cid);
-
-    // Rewrite cids in headers and cids in Classes, Fields, Types and
-    // TypeParameters.
-    {
-      CidRewriteVisitor visitor(old_to_new_cid);
-      I->heap()->VisitObjects(&visitor);
-    }
-  }
-
-#if defined(DEBUG)
-  I->class_table()->Validate();
-  I->heap()->Verify();
-#endif
-}
-
-
-class ClearTypeHashVisitor : public ObjectVisitor {
- public:
-  explicit ClearTypeHashVisitor(Zone* zone)
-      : type_param_(TypeParameter::Handle(zone)),
-        type_(Type::Handle(zone)),
-        type_args_(TypeArguments::Handle(zone)),
-        bounded_type_(BoundedType::Handle(zone)) {}
-
-  void VisitObject(RawObject* obj) {
-    if (obj->IsTypeParameter()) {
-      type_param_ ^= obj;
-      type_param_.SetHash(0);
-    } else if (obj->IsType()) {
-      type_ ^= obj;
-      type_.SetHash(0);
-    } else if (obj->IsBoundedType()) {
-      bounded_type_ ^= obj;
-      bounded_type_.SetHash(0);
-    } else if (obj->IsTypeArguments()) {
-      type_args_ ^= obj;
-      type_args_.SetHash(0);
-    }
-  }
-
- private:
-  TypeParameter& type_param_;
-  Type& type_;
-  TypeArguments& type_args_;
-  BoundedType& bounded_type_;
-};
-
-
-void Precompiler::RehashTypes() {
-  // Clear all cached hash values.
-  {
-    HeapIterationScope his;
-    ClearTypeHashVisitor visitor(Z);
-    I->heap()->VisitObjects(&visitor);
-  }
-
-  // Rehash the canonical Types table.
-  ObjectStore* object_store = I->object_store();
-  GrowableObjectArray& types =
-      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
-  Array& types_array = Array::Handle(Z);
-  Type& type = Type::Handle(Z);
-  {
-    CanonicalTypeSet types_table(Z, object_store->canonical_types());
-    types_array = HashTables::ToArray(types_table, false);
-    for (intptr_t i = 0; i < types_array.Length(); i++) {
-      type ^= types_array.At(i);
-      types.Add(type);
-    }
-    types_table.Release();
-  }
-
-  intptr_t dict_size = Utils::RoundUpToPowerOfTwo(types.Length() * 4 / 3);
-  types_array = HashTables::New<CanonicalTypeSet>(dict_size, Heap::kOld);
-  CanonicalTypeSet types_table(Z, types_array.raw());
-  for (intptr_t i = 0; i < types.Length(); i++) {
-    type ^= types.At(i);
-    bool present = types_table.Insert(type);
-    ASSERT(!present || type.IsRecursive());
-  }
-  object_store->set_canonical_types(types_table.Release());
-
-  // Rehash the canonical TypeArguments table.
-  Array& typeargs_array = Array::Handle(Z);
-  GrowableObjectArray& typeargs =
-      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
-  TypeArguments& typearg = TypeArguments::Handle(Z);
-  {
-    CanonicalTypeArgumentsSet typeargs_table(
-        Z, object_store->canonical_type_arguments());
-    typeargs_array = HashTables::ToArray(typeargs_table, false);
-    for (intptr_t i = 0; i < typeargs_array.Length(); i++) {
-      typearg ^= typeargs_array.At(i);
-      typeargs.Add(typearg);
-    }
-    typeargs_table.Release();
-  }
-
-  dict_size = Utils::RoundUpToPowerOfTwo(typeargs.Length() * 4 / 3);
-  typeargs_array =
-      HashTables::New<CanonicalTypeArgumentsSet>(dict_size, Heap::kOld);
-  CanonicalTypeArgumentsSet typeargs_table(Z, typeargs_array.raw());
-  for (intptr_t i = 0; i < typeargs.Length(); i++) {
-    typearg ^= typeargs.At(i);
-    bool present = typeargs_table.Insert(typearg);
-    ASSERT(!present || typearg.IsRecursive());
-  }
-  object_store->set_canonical_type_arguments(typeargs_table.Release());
-}
-
 
 void Precompiler::VerifyJITFeedback() {
   if (jit_feedback_ == NULL) return;
 
   ParsedJSONString* js_vmversion = jit_feedback_->StringAt("vmVersion");
   if ((js_vmversion == NULL) ||
       strcmp(js_vmversion->value(), Version::CommitString()) != 0) {
     THR_Print(
         "JIT feedback contains invalid vm version "
         "(saw %s, expected %s).\n",
@@ skipping 1013 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart