Precompilation: canonicalize Instructions in PRODUCT mode.

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/cha.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/hash_table.h"
@@ skipping 111 matching lines @@
     DropFunctions();
     DropFields();
 
     // TODO(rmacnak): DropEmptyClasses();
 
     BindStaticCalls();
 
     DedupStackmaps();
     DedupStackmapLists();
 
+    if (FLAG_dedup_instructions) {
+      // Reduces binary size but obfuscates profiler results.
+      DedupInstructions();
+    }
+
     I->object_store()->set_compile_time_constants(Array::null_array());
     I->object_store()->set_unique_dynamic_targets(Array::null_array());
 
     zone_ = NULL;
   }
 
   intptr_t dropped_symbols_count = Symbols::Compact(I);
 
   if (FLAG_trace_precompiler) {
     THR_Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
@@ skipping 1039 matching lines @@
     Code& code_;
     Array& stackmaps_;
     Stackmap& stackmap_;
   };
 
   DedupStackmapListsVisitor visitor(Z);
   VisitFunctions(&visitor);
 }
 
 
+void Precompiler::DedupInstructions() {
+  class DedupInstructionsVisitor : public FunctionVisitor {
+   public:
+    explicit DedupInstructionsVisitor(Zone* zone) :
+      zone_(zone),
+      canonical_instructions_set_(),
+      code_(Code::Handle(zone)),
+      instructions_(Instructions::Handle(zone)) {
+    }
+
+    void VisitFunction(const Function& function) {
+      if (!function.HasCode()) {
+        ASSERT(function.HasImplicitClosureFunction());
+        return;
+      }
+      code_ = function.CurrentCode();
+      instructions_ = code_.instructions();
+      instructions_ = DedupOneInstructions(instructions_);
+      code_.SetActiveInstructions(instructions_.raw());
+      code_.set_instructions(instructions_.raw());
+      function.SetInstructions(code_);  // Update cached entry point.
+    }
+
+    RawInstructions* DedupOneInstructions(const Instructions& instructions) {
+      const Instructions* canonical_instructions =
+          canonical_instructions_set_.Lookup(&instructions);
+      if (canonical_instructions == NULL) {
+        canonical_instructions_set_.Insert(
+            &Instructions::ZoneHandle(zone_, instructions.raw()));
+        return instructions.raw();
+      } else {
+        return canonical_instructions->raw();
+      }
+    }
+
+   private:
+    Zone* zone_;
+    InstructionsSet canonical_instructions_set_;
+    Code& code_;
+    Instructions& instructions_;
+  };
+
+  DedupInstructionsVisitor visitor(Z);
+  VisitFunctions(&visitor);
+}
+
 void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Object& object = Object::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);
@@ skipping 84 matching lines @@
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
       cls.set_is_allocated(false);
     }
   }
 }
 
 }  // namespace dart