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

runtime/vm/deopt_instructions.h

 // Copyright (c) 2013, 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_DEOPT_INSTRUCTIONS_H_
 #define RUNTIME_VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
@@ skipping 355 matching lines @@
   virtual intptr_t source_index() const = 0;
 
   virtual const char* ArgumentsToCString() const { return NULL; }
 
  private:
   static const char* KindToCString(Kind kind);
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInstr);
 };
 
-
 // Helper class that allows to read a value of the given register from
 // the DeoptContext as the specified type.
 // It calls different method depending on which kind of register (cpu/fpu) and
 // destination types are specified.
 template <typename RegisterType, typename DestinationType>
 struct RegisterReader;
 
 template <typename T>
 struct RegisterReader<Register, T> {
   static intptr_t Read(DeoptContext* context, Register reg) {
     return context->RegisterValue(reg);
   }
 };
 
 template <>
 struct RegisterReader<FpuRegister, double> {
   static double Read(DeoptContext* context, FpuRegister reg) {
     return context->FpuRegisterValue(reg);
   }
 };
 
-
 template <>
 struct RegisterReader<FpuRegister, simd128_value_t> {
   static simd128_value_t Read(DeoptContext* context, FpuRegister reg) {
     return context->FpuRegisterValueAsSimd128(reg);
   }
 };
 
-
 // Class that encapsulates reading and writing of values that were either in
 // the registers in the optimized code or were spilled from those registers
 // to the stack.
 template <typename RegisterType>
 class RegisterSource {
  public:
   enum Kind {
     // Spilled register source represented as its spill slot.
     kStackSlot = 0,
     // Register source represented as its register index.
@@ skipping 49 matching lines @@
 
   static const char* Name(Register reg) { return Assembler::RegisterName(reg); }
 
   static const char* Name(FpuRegister fpu_reg) {
     return Assembler::FpuRegisterName(fpu_reg);
   }
 
   const intptr_t source_index_;
 };
 
-
 typedef RegisterSource<Register> CpuRegisterSource;
 typedef RegisterSource<FpuRegister> FpuRegisterSource;
 
-
 // Builds a deoptimization info table, one DeoptInfo at a time.  Call AddXXX
 // methods in the order of their target, starting wih deoptimized code
 // continuation pc and ending with the first argument of the deoptimized
 // code.  Call CreateDeoptInfo to write the accumulated instructions into
 // the heap and reset the builder's internal state for the next DeoptInfo.
 class DeoptInfoBuilder : public ValueObject {
  public:
   DeoptInfoBuilder(Zone* zone, const intptr_t num_args, Assembler* assembler);
 
   // Return address before instruction.
@@ skipping 66 matching lines @@
   // Used to compress entries by sharing suffixes.
   TrieNode* trie_root_;
   intptr_t current_info_number_;
 
   intptr_t frame_start_;
   GrowableArray<MaterializeObjectInstr*> materializations_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInfoBuilder);
 };
 
-
 // Utilities for managing the deopt table and its entries.  The table is
 // stored in an Array in the heap.  It consists of triples of (PC offset,
 // info, reason).  Elements of each entry are stored consecutively in the
 // array.
 // TODO(vegorov): consider compressing the whole table into a single TypedData
 // object.
 class DeoptTable : public AllStatic {
  public:
   // Return the array size in elements for a given number of table entries.
   static intptr_t SizeFor(intptr_t length);
@@ skipping 69 matching lines @@
  private:
   static void UnpackInto(const Array& table,
                          const TypedData& packed,
                          GrowableArray<DeoptInstr*>* instructions,
                          intptr_t length);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEOPT_INSTRUCTIONS_H_