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

runtime/vm/flow_graph_compiler_dbc.cc

Index: runtime/vm/flow_graph_compiler_dbc.cc
diff --git a/runtime/vm/flow_graph_compiler_dbc.cc b/runtime/vm/flow_graph_compiler_dbc.cc
index 992c94ce275fe22555a3841b5348cecb4c559b93..63da152dbbc2b28d10667187b4f6536a6337a81c 100644
--- a/runtime/vm/flow_graph_compiler_dbc.cc
+++ b/runtime/vm/flow_graph_compiler_dbc.cc
@@ -37,7 +37,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-
 bool FlowGraphCompiler::SupportsUnboxedDoubles() {
 #if defined(ARCH_IS_64_BIT)
   return true;
@@ -47,39 +46,32 @@ bool FlowGraphCompiler::SupportsUnboxedDoubles() {
 #endif
 }
 
-
 bool FlowGraphCompiler::SupportsUnboxedMints() {
   return false;
 }
 
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   return false;
 }
 
-
 bool FlowGraphCompiler::SupportsHardwareDivision() {
   return true;
 }
 
-
 bool FlowGraphCompiler::CanConvertUnboxedMintToDouble() {
   return false;
 }
 
-
 void FlowGraphCompiler::EnterIntrinsicMode() {
   ASSERT(!intrinsic_mode());
   intrinsic_mode_ = true;
 }
 
-
 void FlowGraphCompiler::ExitIntrinsicMode() {
   ASSERT(intrinsic_mode());
   intrinsic_mode_ = false;
 }
 
-
 RawTypedData* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler,
                                                  DeoptInfoBuilder* builder,
                                                  const Array& deopt_table) {
@@ -166,7 +158,6 @@ RawTypedData* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler,
   builder->AddPcMarker(previous->function(), slot_ix++);
   builder->AddConstant(previous->function(), slot_ix++);
 
-
   // For the outermost environment, set the incoming arguments.
   for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
     builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i), slot_ix++);
@@ -175,7 +166,6 @@ RawTypedData* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler,
   return builder->CreateDeoptInfo(deopt_table);
 }
 
-
 void FlowGraphCompiler::RecordAfterCallHelper(TokenPosition token_pos,
                                               intptr_t deopt_id,
                                               intptr_t argument_count,
@@ -204,22 +194,18 @@ void FlowGraphCompiler::RecordAfterCallHelper(TokenPosition token_pos,
   }
 }
 
-
 void FlowGraphCompiler::RecordAfterCall(Instruction* instr, CallResult result) {
   RecordAfterCallHelper(instr->token_pos(), instr->deopt_id(),
                         instr->ArgumentCount(), result, instr->locs());
 }
 
-
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   UNREACHABLE();
 }
 
-
 #define __ assembler()->
 
-
 void FlowGraphCompiler::GenerateAssertAssignable(TokenPosition token_pos,
                                                  intptr_t deopt_id,
                                                  const AbstractType& dst_type,
@@ -279,7 +265,6 @@ void FlowGraphCompiler::GenerateAssertAssignable(TokenPosition token_pos,
   }
 }
 
-
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (!is_optimizing()) {
     Definition* defn = instr->AsDefinition();
@@ -294,7 +279,6 @@ void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   }
 }
 
-
 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   __ Move(0, -(1 + kParamEndSlotFromFp));
   ASSERT(offset % kWordSize == 0);
@@ -307,7 +291,6 @@ void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   __ Return(0);
 }
 
-
 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   __ Move(0, -(2 + kParamEndSlotFromFp));
   __ Move(1, -(1 + kParamEndSlotFromFp));
@@ -322,7 +305,6 @@ void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   __ Return(0);
 }
 
-
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   const intptr_t num_fixed_params = function.num_fixed_parameters();
@@ -388,7 +370,6 @@ void FlowGraphCompiler::EmitFrameEntry() {
     }
   }
 
-
   if (has_optional_params) {
     if (!is_optimizing()) {
       ASSERT(num_locals > 0);  // There is always at least context_var.
@@ -429,7 +410,6 @@ void FlowGraphCompiler::EmitFrameEntry() {
   }
 }
 
-
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
 
@@ -442,7 +422,6 @@ void FlowGraphCompiler::CompileGraph() {
   VisitBlocks();
 }
 
-
 uint16_t FlowGraphCompiler::ToEmbeddableCid(intptr_t cid,
                                             Instruction* instruction) {
   if (!Utils::IsUint(16, cid)) {
@@ -452,7 +431,6 @@ uint16_t FlowGraphCompiler::ToEmbeddableCid(intptr_t cid,
   return static_cast<uint16_t>(cid);
 }
 
-
 intptr_t FlowGraphCompiler::CatchEntryRegForVariable(const LocalVariable& var) {
   ASSERT(is_optimizing());
   ASSERT(var.index() <= 0);
@@ -460,11 +438,9 @@ intptr_t FlowGraphCompiler::CatchEntryRegForVariable(const LocalVariable& var) {
          (flow_graph().num_non_copied_params() - var.index());
 }
 
-
 #undef __
 #define __ compiler_->assembler()->
 
-
 void ParallelMoveResolver::EmitMove(int index) {
   MoveOperands* move = moves_[index];
   const Location source = move->src();
@@ -497,7 +473,6 @@ void ParallelMoveResolver::EmitMove(int index) {
   move->Eliminate();
 }
 
-
 void ParallelMoveResolver::EmitSwap(int index) {
   MoveOperands* move = moves_[index];
   const Location source = move->src();
@@ -522,39 +497,33 @@ void ParallelMoveResolver::EmitSwap(int index) {
   }
 }
 
-
 void ParallelMoveResolver::MoveMemoryToMemory(const Address& dst,
                                               const Address& src) {
   UNREACHABLE();
 }
 
-
 void ParallelMoveResolver::StoreObject(const Address& dst, const Object& obj) {
   UNREACHABLE();
 }
 
-
 // Do not call or implement this function. Instead, use the form below that
 // uses an offset from the frame pointer instead of an Address.
 void ParallelMoveResolver::Exchange(Register reg, const Address& mem) {
   UNREACHABLE();
 }
 
-
 // Do not call or implement this function. Instead, use the form below that
 // uses offsets from the frame pointer instead of Addresses.
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   UNREACHABLE();
 }
 
-
 void ParallelMoveResolver::Exchange(Register reg,
                                     Register base_reg,
                                     intptr_t stack_offset) {
   UNIMPLEMENTED();
 }
 
-
 void ParallelMoveResolver::Exchange(Register base_reg1,
                                     intptr_t stack_offset1,
                                     Register base_reg2,
@@ -562,27 +531,22 @@ void ParallelMoveResolver::Exchange(Register base_reg1,
   UNIMPLEMENTED();
 }
 
-
 void ParallelMoveResolver::SpillScratch(Register reg) {
   UNIMPLEMENTED();
 }
 
-
 void ParallelMoveResolver::RestoreScratch(Register reg) {
   UNIMPLEMENTED();
 }
 
-
 void ParallelMoveResolver::SpillFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
-
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
-
 #undef __
 
 }  // namespace dart