Refactor AOT deduplication steps so they can run before an app-jit snapshot as well.

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"
@@ skipping 484 matching lines @@
       I->object_store()->set_async_star_move_next_helper(null_function);
       I->object_store()->set_complete_on_async_return(null_function);
       I->object_store()->set_async_star_stream_controller(null_class);
     }
     DropClasses();
     DropLibraries();
 
     BindStaticCalls();
     SwitchICCalls();
 
-    ShareMegamorphicBuckets();
-    DedupStackMaps();
-    DedupCodeSourceMaps();
-    DedupLists();
-
-    if (FLAG_dedup_instructions) {
-      // Reduces binary size but obfuscates profiler results.
-      DedupInstructions();
-    }
+    ProgramVisitor::Dedup();
 
     zone_ = NULL;
   }
 
   intptr_t symbols_before = -1;
   intptr_t symbols_after = -1;
   intptr_t capacity = -1;
   if (FLAG_trace_precompiler) {
     Symbols::GetStats(I, &symbols_before, &capacity);
   }
@@ skipping 1739 matching lines @@
     UnlinkedCallSet canonical_unlinked_calls_;
   };
 
   ASSERT(!I->compilation_allowed());
   SwitchICCallsVisitor visitor(Z);
   ProgramVisitor::VisitFunctions(&visitor);
 #endif
 }
 
 
-void Precompiler::ShareMegamorphicBuckets() {
-  const GrowableObjectArray& table = GrowableObjectArray::Handle(
-      Z, I->object_store()->megamorphic_cache_table());
-  if (table.IsNull()) return;
-  MegamorphicCache& cache = MegamorphicCache::Handle(Z);
-
-  const intptr_t capacity = 1;
-  const Array& buckets = Array::Handle(
-      Z, Array::New(MegamorphicCache::kEntryLength * capacity, Heap::kOld));
-  const Function& handler =
-      Function::Handle(Z, MegamorphicCacheTable::miss_handler(I));
-  MegamorphicCache::SetEntry(buckets, 0, MegamorphicCache::smi_illegal_cid(),
-                             handler);
-
-  for (intptr_t i = 0; i < table.Length(); i++) {
-    cache ^= table.At(i);
-    cache.set_buckets(buckets);
-    cache.set_mask(capacity - 1);
-    cache.set_filled_entry_count(0);
-  }
-}
-
-
-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 Visit(const Function& function) {
-      if (!function.HasCode()) {
-        return;
-      }
-      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_.LookupValue(&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);
-  ProgramVisitor::VisitFunctions(&visitor);
-}
-
-
-void Precompiler::DedupCodeSourceMaps() {
-  class DedupCodeSourceMapsVisitor : public FunctionVisitor {
-   public:
-    explicit DedupCodeSourceMapsVisitor(Zone* zone)
-        : zone_(zone),
-          canonical_code_source_maps_(),
-          code_(Code::Handle(zone)),
-          code_source_map_(CodeSourceMap::Handle(zone)) {}
-
-    void Visit(const Function& function) {
-      if (!function.HasCode()) {
-        return;
-      }
-      code_ = function.CurrentCode();
-      code_source_map_ = code_.code_source_map();
-      ASSERT(!code_source_map_.IsNull());
-      code_source_map_ = DedupCodeSourceMap(code_source_map_);
-      code_.set_code_source_map(code_source_map_);
-    }
-
-    RawCodeSourceMap* DedupCodeSourceMap(const CodeSourceMap& code_source_map) {
-      const CodeSourceMap* canonical_code_source_map =
-          canonical_code_source_maps_.LookupValue(&code_source_map);
-      if (canonical_code_source_map == NULL) {
-        canonical_code_source_maps_.Insert(
-            &CodeSourceMap::ZoneHandle(zone_, code_source_map.raw()));
-        return code_source_map.raw();
-      } else {
-        return canonical_code_source_map->raw();
-      }
-    }
-
-   private:
-    Zone* zone_;
-    CodeSourceMapSet canonical_code_source_maps_;
-    Code& code_;
-    CodeSourceMap& code_source_map_;
-  };
-
-  DedupCodeSourceMapsVisitor visitor(Z);
-  ProgramVisitor::VisitFunctions(&visitor);
-}
-
-
-void Precompiler::DedupLists() {
-  class DedupListsVisitor : public FunctionVisitor {
-   public:
-    explicit DedupListsVisitor(Zone* zone)
-        : zone_(zone),
-          canonical_lists_(),
-          code_(Code::Handle(zone)),
-          list_(Array::Handle(zone)) {}
-
-    void Visit(const Function& function) {
-      code_ = function.CurrentCode();
-      if (!code_.IsNull()) {
-        list_ = code_.stackmaps();
-        if (!list_.IsNull()) {
-          list_ = DedupList(list_);
-          code_.set_stackmaps(list_);
-        }
-        list_ = code_.inlined_id_to_function();
-        if (!list_.IsNull()) {
-          list_ = DedupList(list_);
-          code_.set_inlined_id_to_function(list_);
-        }
-      }
-
-      list_ = function.parameter_types();
-      if (!list_.IsNull()) {
-        if (!function.IsSignatureFunction() && !function.IsClosureFunction() &&
-            (function.name() != Symbols::Call().raw()) && !list_.InVMHeap()) {
-          // Parameter types not needed for function type tests.
-          for (intptr_t i = 0; i < list_.Length(); i++) {
-            list_.SetAt(i, Object::dynamic_type());
-          }
-        }
-        list_ = DedupList(list_);
-        function.set_parameter_types(list_);
-      }
-
-      list_ = function.parameter_names();
-      if (!list_.IsNull()) {
-        if (!function.HasOptionalNamedParameters() && !list_.InVMHeap()) {
-          // Parameter names not needed for resolution.
-          for (intptr_t i = 0; i < list_.Length(); i++) {
-            list_.SetAt(i, Symbols::OptimizedOut());
-          }
-        }
-        list_ = DedupList(list_);
-        function.set_parameter_names(list_);
-      }
-    }
-
-    RawArray* DedupList(const Array& list) {
-      const Array* canonical_list = canonical_lists_.LookupValue(&list);
-      if (canonical_list == NULL) {
-        canonical_lists_.Insert(&Array::ZoneHandle(zone_, list.raw()));
-        return list.raw();
-      } else {
-        return canonical_list->raw();
-      }
-    }
-
-   private:
-    Zone* zone_;
-    ArraySet canonical_lists_;
-    Code& code_;
-    Array& list_;
-  };
-
-  DedupListsVisitor visitor(Z);
-  ProgramVisitor::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 Visit(const Function& function) {
-      if (!function.HasCode()) {
-        ASSERT(function.HasImplicitClosureFunction());
-        return;
-      }
-      code_ = function.CurrentCode();
-      instructions_ = code_.instructions();
-      instructions_ = DedupOneInstructions(instructions_);
-      code_.SetActiveInstructions(instructions_);
-      code_.set_instructions(instructions_);
-      function.SetInstructions(code_);  // Update cached entry point.
-    }
-
-    RawInstructions* DedupOneInstructions(const Instructions& instructions) {
-      const Instructions* canonical_instructions =
-          canonical_instructions_set_.LookupValue(&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);
-  ProgramVisitor::VisitFunctions(&visitor);
-}
-
-
 void Precompiler::FinalizeAllClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     if (!lib.Loaded()) {
       String& uri = String::Handle(Z, lib.url());
       String& msg = String::Handle(
           Z,
@@ skipping 1051 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