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

runtime/vm/flow_graph_compiler.h

 // Copyright (c) 2012, 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.
 
 #ifndef RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 #define RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
 #include "vm/intermediate_language.h"
 #include "vm/runtime_entry.h"
 
 namespace dart {
 
 // Forward declarations.
 class Code;
 class DeoptInfoBuilder;
 class FlowGraph;
 class FlowGraphCompiler;
 class Function;
 template <typename T>
 class GrowableArray;
 class ParsedFunction;
 
-
 class ParallelMoveResolver : public ValueObject {
  public:
   explicit ParallelMoveResolver(FlowGraphCompiler* compiler);
 
   // Resolve a set of parallel moves, emitting assembler instructions.
   void EmitNativeCode(ParallelMoveInstr* parallel_move);
 
  private:
   class ScratchFpuRegisterScope : public ValueObject {
    public:
@@ skipping 15 matching lines @@
     ~ScratchRegisterScope();
 
     Register reg() const { return reg_; }
 
    private:
     ParallelMoveResolver* resolver_;
     Register reg_;
     bool spilled_;
   };
 
-
   bool IsScratchLocation(Location loc);
   intptr_t AllocateScratchRegister(Location::Kind kind,
                                    uword blocked_mask,
                                    intptr_t first_free_register,
                                    intptr_t last_free_register,
                                    bool* spilled);
 
   void SpillScratch(Register reg);
   void RestoreScratch(Register reg);
   void SpillFpuScratch(FpuRegister reg);
@@ skipping 29 matching lines @@
                 intptr_t stack_offset1,
                 Register base_reg2,
                 intptr_t stack_offset2);
 
   FlowGraphCompiler* compiler_;
 
   // List of moves not yet resolved.
   GrowableArray<MoveOperands*> moves_;
 };
 
-
 // Used for describing a deoptimization point after call (lazy deoptimization).
 // For deoptimization before instruction use class CompilerDeoptInfoWithStub.
 class CompilerDeoptInfo : public ZoneAllocated {
  public:
   CompilerDeoptInfo(intptr_t deopt_id,
                     ICData::DeoptReasonId reason,
                     uint32_t flags,
                     Environment* deopt_env)
       : pc_offset_(-1),
         deopt_id_(deopt_id),
         reason_(reason),
         flags_(flags),
 #if defined(TARGET_ARCH_DBC)
         lazy_deopt_with_result_(false),
 #endif
         deopt_env_(deopt_env) {
     ASSERT(deopt_env != NULL);
   }
   virtual ~CompilerDeoptInfo() {}
 
   RawTypedData* CreateDeoptInfo(FlowGraphCompiler* compiler,
                                 DeoptInfoBuilder* builder,
                                 const Array& deopt_table);
 
-
   // No code needs to be generated.
   virtual void GenerateCode(FlowGraphCompiler* compiler, intptr_t stub_ix) {}
 
   intptr_t pc_offset() const { return pc_offset_; }
   void set_pc_offset(intptr_t offset) { pc_offset_ = offset; }
 
   intptr_t deopt_id() const { return deopt_id_; }
   ICData::DeoptReasonId reason() const { return reason_; }
   uint32_t flags() const { return flags_; }
   const Environment* deopt_env() const { return deopt_env_; }
@@ skipping 21 matching lines @@
   const ICData::DeoptReasonId reason_;
   const uint32_t flags_;
 #if defined(TARGET_ARCH_DBC)
   bool lazy_deopt_with_result_;
 #endif
   Environment* deopt_env_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerDeoptInfo);
 };
 
-
 class CompilerDeoptInfoWithStub : public CompilerDeoptInfo {
  public:
   CompilerDeoptInfoWithStub(intptr_t deopt_id,
                             ICData::DeoptReasonId reason,
                             uint32_t flags,
                             Environment* deopt_env)
       : CompilerDeoptInfo(deopt_id, reason, flags, deopt_env), entry_label_() {
     ASSERT(reason != ICData::kDeoptAtCall);
   }
 
@@ skipping 12 matching lines @@
                 DeoptReasonToCString(reason()));
     return chars;
   }
 
  private:
   Label entry_label_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerDeoptInfoWithStub);
 };
 
-
 class SlowPathCode : public ZoneAllocated {
  public:
   SlowPathCode() : entry_label_(), exit_label_() {}
   virtual ~SlowPathCode() {}
 
   Label* entry_label() { return &entry_label_; }
   Label* exit_label() { return &exit_label_; }
 
   void GenerateCode(FlowGraphCompiler* compiler) {
     EmitNativeCode(compiler);
     ASSERT(entry_label_.IsBound());
   }
 
  private:
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
   Label entry_label_;
   Label exit_label_;
 
   DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
 };
 
-
 class FlowGraphCompiler : public ValueObject {
  private:
   class BlockInfo : public ZoneAllocated {
    public:
     BlockInfo()
         : block_label_(),
           jump_label_(&block_label_),
           next_nonempty_label_(NULL),
           is_marked_(false) {}
 
@@ skipping 595 matching lines @@
   ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data_;
 
   Array& edge_counters_array_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_COMPILER_H_