VM: Re-format to use at most one newline between functions

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"
-#include "vm/hash_map.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 void ProgramVisitor::VisitClasses(ClassVisitor* visitor) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
   Library& lib = Library::Handle(zone);
   Class& cls = Class::Handle(zone);
 
   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.
       }
       visitor->Visit(cls);
     }
   }
 }
 
-
 void ProgramVisitor::VisitFunctions(FunctionVisitor* visitor) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
   Library& lib = Library::Handle(zone);
   Class& cls = Class::Handle(zone);
   Array& functions = Array::Handle(zone);
   Array& fields = Array::Handle(zone);
@@ skipping 40 matching lines @@
     }
   }
   closures = isolate->object_store()->closure_functions();
   for (intptr_t j = 0; j < closures.Length(); j++) {
     function ^= closures.At(j);
     visitor->Visit(function);
     ASSERT(!function.HasImplicitClosureFunction());
   }
 }
 
-
 void ProgramVisitor::ShareMegamorphicBuckets() {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
 
   const GrowableObjectArray& table = GrowableObjectArray::Handle(
       zone, isolate->object_store()->megamorphic_cache_table());
   if (table.IsNull()) return;
   MegamorphicCache& cache = MegamorphicCache::Handle(zone);
 
   const intptr_t capacity = 1;
   const Array& buckets = Array::Handle(
       zone, Array::New(MegamorphicCache::kEntryLength * capacity, Heap::kOld));
   const Function& handler =
       Function::Handle(zone, MegamorphicCacheTable::miss_handler(isolate));
   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);
   }
 }
 
-
 class StackMapKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const StackMap* Key;
   typedef const StackMap* Value;
   typedef const StackMap* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->PcOffset(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<StackMapKeyValueTrait> StackMapSet;
 
-
 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)) {}
 
@@ skipping 28 matching lines @@
     StackMapSet canonical_stackmaps_;
     Code& code_;
     Array& stackmaps_;
     StackMap& stackmap_;
   };
 
   DedupStackMapsVisitor visitor(Thread::Current()->zone());
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 class PcDescriptorsKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const PcDescriptors* Key;
   typedef const PcDescriptors* Value;
   typedef const PcDescriptors* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Length(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<PcDescriptorsKeyValueTrait> PcDescriptorsSet;
 
-
 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 Visit(const Function& function) {
@@ skipping 23 matching lines @@
     Zone* zone_;
     PcDescriptorsSet canonical_pc_descriptors_;
     Code& code_;
     PcDescriptors& pc_descriptor_;
   };
 
   DedupPcDescriptorsVisitor visitor(Thread::Current()->zone());
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 class TypedDataKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const TypedData* Key;
   typedef const TypedData* Value;
   typedef const TypedData* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) {
     return key->ComputeCanonicalTableHash();
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->CanonicalizeEquals(*key);
   }
 };
 
 typedef DirectChainedHashMap<TypedDataKeyValueTrait> TypedDataSet;
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 void ProgramVisitor::DedupDeoptEntries() {
   class DedupDeoptEntriesVisitor : public FunctionVisitor {
    public:
     explicit DedupDeoptEntriesVisitor(Zone* zone)
         : zone_(zone),
           canonical_deopt_entries_(),
           code_(Code::Handle(zone)),
           deopt_table_(Array::Handle(zone)),
           deopt_entry_(TypedData::Handle(zone)),
@@ skipping 39 matching lines @@
     TypedData& deopt_entry_;
     Smi& offset_;
     Smi& reason_and_flags_;
   };
 
   DedupDeoptEntriesVisitor visitor(Thread::Current()->zone());
   ProgramVisitor::VisitFunctions(&visitor);
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-
 class CodeSourceMapKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const CodeSourceMap* Key;
   typedef const CodeSourceMap* Value;
   typedef const CodeSourceMap* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Length(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<CodeSourceMapKeyValueTrait> CodeSourceMapSet;
 
-
 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 Visit(const Function& function) {
@@ skipping 23 matching lines @@
     Zone* zone_;
     CodeSourceMapSet canonical_code_source_maps_;
     Code& code_;
     CodeSourceMap& code_source_map_;
   };
 
   DedupCodeSourceMapsVisitor visitor(Thread::Current()->zone());
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 class ArrayKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Array* Key;
   typedef const Array* Value;
   typedef const Array* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Length(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     if (pair->Length() != key->Length()) {
       return false;
     }
     for (intptr_t i = 0; i < pair->Length(); i++) {
       if (pair->At(i) != key->At(i)) {
         return false;
       }
     }
     return true;
   }
 };
 
 typedef DirectChainedHashMap<ArrayKeyValueTrait> ArraySet;
 
-
 void ProgramVisitor::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) {
@@ skipping 77 matching lines @@
     Zone* zone_;
     ArraySet canonical_lists_;
     Code& code_;
     Array& list_;
   };
 
   DedupListsVisitor visitor(Thread::Current()->zone());
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
-
 class InstructionsKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Instructions* Key;
   typedef const Instructions* Value;
   typedef const Instructions* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   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 {
    public:
     explicit DedupInstructionsVisitor(Zone* zone)
         : zone_(zone),
           canonical_instructions_set_(),
           code_(Code::Handle(zone)),
           instructions_(Instructions::Handle(zone)) {}
 
     void Visit(const Function& function) {
@@ skipping 24 matching lines @@
     Zone* zone_;
     InstructionsSet canonical_instructions_set_;
     Code& code_;
     Instructions& instructions_;
   };
 
   DedupInstructionsVisitor visitor(Thread::Current()->zone());
   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 (!FLAG_profiler) {
     // Reduces binary size but obfuscates profiler results.
     DedupInstructions();
   }
 }
 
 }  // namespace dart