Dedup stackmaps.

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/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 43 matching lines @@
   changed_(false),
   function_count_(0),
   class_count_(0),
   selector_count_(0),
   dropped_function_count_(0),
   libraries_(GrowableObjectArray::Handle(Z, I->object_store()->libraries())),
   pending_functions_(GrowableObjectArray::Handle(Z,
                                                  GrowableObjectArray::New())),
   collected_closures_(GrowableObjectArray::Handle(Z, I->collected_closures())),
   sent_selectors_(Z),
+  stackmaps_(Z),
   error_(Error::Handle(Z)) {
 }
 
 
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
   // Drop all existing code so we can use the presence of code as an indicator
   // that we have already looked for the function's callees.
   ClearAllCode();
 
@@ skipping 250 matching lines @@
 
 
 void Precompiler::CleanUp() {
   I->set_collected_closures(GrowableObjectArray::Handle(Z));
 
   DropUncompiledFunctions();
 
   // TODO(rmacnak): DropEmptyClasses();
 
   BindStaticCalls();
+
+  DedupStackmaps();
 }
 
 
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Precompiling %" Pd " %s (%" Pd ", %s)\n",
                 function_count_,
@@ skipping 413 matching lines @@
       CodePatcher::PatchStaticCallAt(pc_offset.Value() + code.EntryPoint(),
                                      code, target_code);
     }
   }
 
   // We won't patch static calls anymore, so drop the static call table to save
   // space.
   code.set_static_calls_target_table(Object::empty_array());
 }
 
+
+void Precompiler::DedupStackmaps() {
+  Library& lib = Library::Handle(Z);

[Florian Schneider, 2015/10/07 10:40:07]

This code for iterating over all functions seems to be used in multiple places.
Maybe factor it out into Function-Iterator?

[rmacnak, 2015/10/07 22:19:06]

Recast as visitor. Covers clear code, bind static calls and dedup stackmaps, but
shrinking the function tables and finding new dynamic functions still have
custom iteration.

+  Class& cls = Class::Handle(Z);
+  Array& functions = Array::Handle(Z);
+  Function& function = Function::Handle(Z);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
+
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
+    while (it.HasNext()) {
+      cls = it.GetNextClass();
+      if (cls.IsDynamicClass()) {
+        continue;  // class 'dynamic' is in the read-only VM isolate.
+      }
+
+      functions = cls.functions();
+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        function ^= functions.At(j);
+        DedupStackmaps(function);
+      }
+
+      closures = cls.closures();
+      if (!closures.IsNull()) {
+        for (intptr_t j = 0; j < closures.Length(); j++) {
+          function ^= closures.At(j);
+          DedupStackmaps(function);
+        }
+      }
+    }
+  }
+}
+
+
+void Precompiler::DedupStackmaps(const Function& function) {
+  Code& code = Code::Handle(Z, function.CurrentCode());
+  Array& stackmaps = Array::Handle(Z, code.stackmaps());
+  if (stackmaps.IsNull()) return;
+  Stackmap& stackmap = Stackmap::Handle(Z);
+  for (intptr_t i = 0; i < stackmaps.Length(); i++) {
+    stackmap ^= stackmaps.At(i);
+    stackmap = DedupStackmap(stackmap);
+    stackmaps.SetAt(i, stackmap);
+  }
+}
+
+
+RawStackmap* Precompiler::DedupStackmap(const Stackmap& stackmap) {
+  const Stackmap* canonical_stackmap = stackmaps_.Lookup(stackmap);
+  if (canonical_stackmap == NULL) {
+    stackmaps_.Add(Stackmap::ZoneHandle(Z, stackmap.raw()));
+    return stackmap.raw();
+  } else {
+    return canonical_stackmap->raw();
+  }
+}
+
 }  // namespace dart