When deduplicating program metadata, try to use objects from the VM isolate.

runtime/vm/program_visitor.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/program_visitor.h"
 
 #include "vm/deopt_instructions.h"
 #include "vm/hash_map.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 132 matching lines @@
 void ProgramVisitor::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 AddStackMap(const StackMap& stackmap) {
+      canonical_stackmaps_.Insert(&StackMap::ZoneHandle(zone_, stackmap.raw()));
+    }
+
     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()));
+        AddStackMap(stackmap);
         return stackmap.raw();
       } else {
         return canonical_stackmap->raw();
       }
     }
 
    private:
     Zone* zone_;
     StackMapSet canonical_stackmaps_;
     Code& code_;
     Array& stackmaps_;
     StackMap& stackmap_;
   };
 
   DedupStackMapsVisitor visitor(Thread::Current()->zone());
+  if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
+    // Prefer existing objects in the VM isolate.
+    const Array& object_table = Object::vm_isolate_snapshot_object_table();
+    Object& object = Object::Handle();
+    for (intptr_t i = 0; i < object_table.Length(); i++) {
+      object = object_table.At(i);
+      if (object.IsStackMap()) {
+        visitor.AddStackMap(StackMap::Cast(object));
+      }
+    }
+  }
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
 class PcDescriptorsKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const PcDescriptors* Key;
   typedef const PcDescriptors* Value;
   typedef const PcDescriptors* Pair;
 
@@ skipping 12 matching lines @@
 
 void ProgramVisitor::DedupPcDescriptors() {
   class DedupPcDescriptorsVisitor : public FunctionVisitor {
    public:
     explicit DedupPcDescriptorsVisitor(Zone* zone)
         : zone_(zone),
           canonical_pc_descriptors_(),
           code_(Code::Handle(zone)),
           pc_descriptor_(PcDescriptors::Handle(zone)) {}
 
+    void AddPcDescriptor(const PcDescriptors& pc_descriptor) {
+      canonical_pc_descriptors_.Insert(
+          &PcDescriptors::ZoneHandle(zone_, pc_descriptor.raw()));
+    }
+
     void Visit(const Function& function) {
       if (!function.HasCode()) {
         return;
       }
       code_ = function.CurrentCode();
       pc_descriptor_ = code_.pc_descriptors();
       if (pc_descriptor_.IsNull()) return;
       pc_descriptor_ = DedupPcDescriptor(pc_descriptor_);
       code_.set_pc_descriptors(pc_descriptor_);
     }
 
     RawPcDescriptors* DedupPcDescriptor(const PcDescriptors& pc_descriptor) {
       const PcDescriptors* canonical_pc_descriptor =
           canonical_pc_descriptors_.LookupValue(&pc_descriptor);
       if (canonical_pc_descriptor == NULL) {
-        canonical_pc_descriptors_.Insert(
-            &PcDescriptors::ZoneHandle(zone_, pc_descriptor.raw()));
+        AddPcDescriptor(pc_descriptor);
         return pc_descriptor.raw();
       } else {
         return canonical_pc_descriptor->raw();
       }
     }
 
    private:
     Zone* zone_;
     PcDescriptorsSet canonical_pc_descriptors_;
     Code& code_;
     PcDescriptors& pc_descriptor_;
   };
 
   DedupPcDescriptorsVisitor visitor(Thread::Current()->zone());
+  if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
+    // Prefer existing objects in the VM isolate.
+    const Array& object_table = Object::vm_isolate_snapshot_object_table();
+    Object& object = Object::Handle();
+    for (intptr_t i = 0; i < object_table.Length(); i++) {
+      object = object_table.At(i);
+      if (object.IsPcDescriptors()) {
+        visitor.AddPcDescriptor(PcDescriptors::Cast(object));
+      }
+    }
+  }
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
 class TypedDataKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const TypedData* Key;
   typedef const TypedData* Value;
   typedef const TypedData* Pair;
 
@@ skipping 93 matching lines @@
 
 void ProgramVisitor::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 AddCodeSourceMap(const CodeSourceMap& code_source_map) {
+      canonical_code_source_maps_.Insert(
+          &CodeSourceMap::ZoneHandle(zone_, code_source_map.raw()));
+    }
+
     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()));
+        AddCodeSourceMap(code_source_map);
         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(Thread::Current()->zone());
+  if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
+    // Prefer existing objects in the VM isolate.
+    const Array& object_table = Object::vm_isolate_snapshot_object_table();
+    Object& object = Object::Handle();
+    for (intptr_t i = 0; i < object_table.Length(); i++) {
+      object = object_table.At(i);
+      if (object.IsCodeSourceMap()) {
+        visitor.AddCodeSourceMap(CodeSourceMap::Cast(object));
+      }
+    }
+  }
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
 class ArrayKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Array* Key;
   typedef const Array* Value;
   typedef const Array* Pair;
 
@@ skipping 129 matching lines @@
   static inline intptr_t Hashcode(Key key) { return key->Size(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<InstructionsKeyValueTrait> InstructionsSet;
 
 void ProgramVisitor::DedupInstructions() {
-  class DedupInstructionsVisitor : public FunctionVisitor {
+  class DedupInstructionsVisitor : public FunctionVisitor,
+                                   public ObjectVisitor {
    public:
     explicit DedupInstructionsVisitor(Zone* zone)
         : zone_(zone),
           canonical_instructions_set_(),
           code_(Code::Handle(zone)),
           instructions_(Instructions::Handle(zone)) {}
 
+    void VisitObject(RawObject* obj) {
+      if (obj->IsInstructions()) {
+        canonical_instructions_set_.Insert(
+            &Instructions::ZoneHandle(zone_, Instructions::RawCast(obj)));
+      }
+    }
+
     void Visit(const Function& function) {
       if (!function.HasCode()) {
         return;
       }
       code_ = function.CurrentCode();
       instructions_ = code_.instructions();
       instructions_ = DedupOneInstructions(instructions_);
       code_.SetActiveInstructions(instructions_);
       code_.set_instructions(instructions_);
       function.SetInstructions(code_);  // Update cached entry point.
@@ skipping 12 matching lines @@
     }
 
    private:
     Zone* zone_;
     InstructionsSet canonical_instructions_set_;
     Code& code_;
     Instructions& instructions_;
   };
 
   DedupInstructionsVisitor visitor(Thread::Current()->zone());
+  if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
+    // Prefer existing objects in the VM isolate.
+    Dart::vm_isolate()->heap()->VisitObjectsImagePages(&visitor);
+  }
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
 void ProgramVisitor::Dedup() {
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   HANDLESCOPE(thread);
 
   // TODO(rmacnak): Bind static calls whose target has been compiled. Forward
   // references to disabled code.
   ShareMegamorphicBuckets();
   DedupStackMaps();
   DedupPcDescriptors();
   NOT_IN_PRECOMPILED(DedupDeoptEntries());
   DedupCodeSourceMaps();
   DedupLists();
 
 #if defined(PRODUCT)
   // Reduces binary size but obfuscates profiler results.
   DedupInstructions();
 #endif
 }
 
 }  // namespace dart