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 42 matching lines @@
   reset_fields_(reset_fields),
   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),
+  sent_selectors_(),
   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 16 matching lines @@
               class_count_,
               selector_count_,
               dropped_function_count_);
   }
 
   I->set_compilation_allowed(false);
 }
 
 
 void Precompiler::ClearAllCode() {
-  Library& lib = Library::Handle(Z);
-  Class& cls = Class::Handle(Z);
-  Array& functions = Array::Handle(Z);
-  Function& function = Function::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();
-      error_ = cls.EnsureIsFinalized(thread_);
-      if (!error_.IsNull()) {
-        Jump(error_);
-      }
+  class CodeCodeFunctionVisitor : public FunctionVisitor {
+    void VisitFunction(const Function& function) {
+      function.ClearCode();
     }
-  }
-
-  for (intptr_t i = 0; i < libraries_.Length(); i++) {
-    lib ^= libraries_.At(i);
-    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
-    while (it.HasNext()) {
-      cls = it.GetNextClass();
-      functions = cls.functions();
-      for (intptr_t i = 0; i < functions.Length(); i++) {
-        function ^= functions.At(i);
-        function.ClearCode();
-      }
-    }
-  }
+  };
+  CodeCodeFunctionVisitor visitor;
+  VisitFunctions(&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.
@@ skipping 185 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 132 matching lines @@
 
   pending_functions_.Add(function);
   changed_ = true;
 }
 
 
 bool Precompiler::IsSent(const String& selector) {
   if (selector.IsNull()) {
     return false;
   }
-  return sent_selectors_.Includes(selector);
+  return sent_selectors_.Lookup(&selector) != NULL;
 }
 
 
 void Precompiler::AddSelector(const String& selector) {
   ASSERT(!selector.IsNull());
 
   if (!IsSent(selector)) {
-    sent_selectors_.Add(selector);
+    sent_selectors_.Insert(&String::ZoneHandle(Z, selector.raw()));
     selector_count_++;
     changed_ = true;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Enqueueing selector %" Pd " %s\n",
                 selector_count_,
                 selector.ToCString());
     }
   }
 }
@@ skipping 184 matching lines @@
           function ^= closures.At(j);
           ASSERT(function.HasCode());
         }
       }
     }
   }
 }
 
 
 void Precompiler::BindStaticCalls() {
+  class BindStaticCallsVisitor : public FunctionVisitor {
+   public:
+    explicit BindStaticCallsVisitor(Zone* zone) :
+        code_(Code::Handle(zone)),
+        table_(Array::Handle(zone)),
+        pc_offset_(Smi::Handle(zone)),
+        target_(Function::Handle(zone)),
+        target_code_(Code::Handle(zone)) {
+    }
+
+    void VisitFunction(const Function& function) {
+      ASSERT(function.HasCode());
+      code_ = function.CurrentCode();
+      table_ = code_.static_calls_target_table();
+
+      for (intptr_t i = 0;
+           i < table_.Length();
+           i += Code::kSCallTableEntryLength) {
+        pc_offset_ ^= table_.At(i + Code::kSCallTableOffsetEntry);
+        target_ ^= table_.At(i + Code::kSCallTableFunctionEntry);
+        if (target_.IsNull()) {
+          target_code_ ^= table_.At(i + Code::kSCallTableCodeEntry);
+          ASSERT(!target_code_.IsNull());
+          ASSERT(!target_code_.IsFunctionCode());
+          // Allocation stub or AllocateContext or AllocateArray or ...
+        } else {
+          // Static calls initially call the CallStaticFunction stub because
+          // their target might not be compiled yet. After tree shaking, all
+          // static call targets are compiled.
+          // Cf. runtime entry PatchStaticCall called from CallStaticFunction
+          // stub.
+          ASSERT(target_.HasCode());
+          target_code_ ^= target_.CurrentCode();
+          uword pc = pc_offset_.Value() + code_.EntryPoint();
+          CodePatcher::PatchStaticCallAt(pc, 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());
+    }
+
+   private:
+    Code& code_;
+    Array& table_;
+    Smi& pc_offset_;
+    Function& target_;
+    Code& target_code_;
+  };
+
+  BindStaticCallsVisitor visitor(Z);
+  VisitFunctions(&visitor);
+}
+
+
+void Precompiler::DedupStackmaps() {
+  class DedupStackmapsVisitor : public FunctionVisitor {
+   public:
+    explicit DedupStackmapsVisitor(Zone* zone) :
+      zone_(zone),
+      canonical_stackmaps_(),
+      code_(Code::Handle(zone)),
+      stackmaps_(Array::Handle(zone)),
+      stackmap_(Stackmap::Handle(zone)) {
+    }
+
+    void VisitFunction(const Function& function) {
+      code_ = function.CurrentCode();
+      stackmaps_ = code_.stackmaps();
+      if (stackmaps_.IsNull()) return;
+      for (intptr_t i = 0; i < stackmaps_.Length(); i++) {
+        stackmap_ ^= stackmaps_.At(i);
+        stackmap_ = DedupStackmap(stackmap_);
+        stackmaps_.SetAt(i, stackmap_);
+      }
+    }
+
+    RawStackmap* DedupStackmap(const Stackmap& stackmap) {
+      const Stackmap* canonical_stackmap =
+          canonical_stackmaps_.Lookup(&stackmap);
+      if (canonical_stackmap == NULL) {
+        canonical_stackmaps_.Insert(
+            &Stackmap::ZoneHandle(zone_, stackmap.raw()));
+        return stackmap.raw();
+      } else {
+        return canonical_stackmap->raw();
+      }
+    }
+
+   private:
+    Zone* zone_;
+    StackmapSet canonical_stackmaps_;
+    Code& code_;
+    Array& stackmaps_;
+    Stackmap& stackmap_;
+  };
+
+  DedupStackmapsVisitor visitor(Z);
+  VisitFunctions(&visitor);
+}
+
+
+void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
   Library& lib = Library::Handle(Z);
   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);
-        BindStaticCalls(function);
+        visitor->VisitFunction(function);
       }
 
       closures = cls.closures();
       if (!closures.IsNull()) {
         for (intptr_t j = 0; j < closures.Length(); j++) {
           function ^= closures.At(j);
-          BindStaticCalls(function);
+          visitor->VisitFunction(function);
         }
       }
     }
   }
 }
 
-
-void Precompiler::BindStaticCalls(const Function& function) {
-  ASSERT(function.HasCode());
-
-  const Code& code = Code::Handle(Z, function.CurrentCode());
-
-  const Array& table = Array::Handle(Z, code.static_calls_target_table());
-  Smi& pc_offset = Smi::Handle(Z);
-  Function& target = Function::Handle(Z);
-  Code& target_code = Code::Handle(Z);
-
-  for (intptr_t i = 0; i < table.Length(); i += Code::kSCallTableEntryLength) {
-    pc_offset ^= table.At(i + Code::kSCallTableOffsetEntry);
-    target ^= table.At(i + Code::kSCallTableFunctionEntry);
-    if (target.IsNull()) {
-      target_code ^= table.At(i + Code::kSCallTableCodeEntry);
-      ASSERT(!target_code.IsNull());
-      ASSERT(!target_code.IsFunctionCode());
-      // Allocation stub or AllocateContext or AllocateArray or ...
-    } else {
-      // Static calls initially call the CallStaticFunction stub because
-      // their target might not be compiled yet. After tree shaking, all
-      // static call targets are compiled.
-      // Cf. runtime entry PatchStaticCall called from CallStaticFunction stub.
-      ASSERT(target.HasCode());
-      target_code ^= target.CurrentCode();
-      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());
-}
-
 }  // namespace dart