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

runtime/vm/branch_optimizer.cc

 // Copyright (c) 2016, 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/branch_optimizer.h"
 
 #include "vm/flow_graph.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
@@ skipping 11 matching lines @@
        env_use = env_use->next_use()) {
     if ((env_use->instruction() != block) &&
         (env_use->instruction() != use->instruction())) {
       return false;
     }
   }
 
   return true;
 }
 
-
 bool BranchSimplifier::Match(JoinEntryInstr* block) {
   // Match the pattern of a branch on a comparison whose left operand is a
   // phi from the same block, and whose right operand is a constant.
   //
   //   Branch(Comparison(kind, Phi, Constant))
   //
   // These are the branches produced by inlining in a test context.  Also,
   // the phi has no other uses so they can simply be eliminated.  The block
   // has no other phis and no instructions intervening between the phi and
   // branch so the block can simply be eliminated.
   BranchInstr* branch = block->last_instruction()->AsBranch();
   ASSERT(branch != NULL);
   ComparisonInstr* comparison = branch->comparison();
   if (comparison->InputCount() != 2) {
     return false;
   }
   if (comparison->CanDeoptimize() || comparison->MayThrow()) {
     return false;
   }
   Value* left = comparison->left();
   PhiInstr* phi = left->definition()->AsPhi();
   Value* right = comparison->right();
   ConstantInstr* constant =
       (right == NULL) ? NULL : right->definition()->AsConstant();
   return (phi != NULL) && (constant != NULL) && (phi->GetBlock() == block) &&
          PhiHasSingleUse(phi, left) && (block->next() == branch) &&
          (block->phis()->length() == 1);
 }
 
-
 JoinEntryInstr* BranchSimplifier::ToJoinEntry(Zone* zone,
                                               TargetEntryInstr* target) {
   // Convert a target block into a join block.  Branches will be duplicated
   // so the former true and false targets become joins of the control flows
   // from all the duplicated branches.
   JoinEntryInstr* join = new (zone) JoinEntryInstr(
       target->block_id(), target->try_index(), Thread::kNoDeoptId);
   join->InheritDeoptTarget(zone, target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
   target->UnuseAllInputs();
   return join;
 }
 
-
 BranchInstr* BranchSimplifier::CloneBranch(Zone* zone,
                                            BranchInstr* branch,
                                            Value* new_left,
                                            Value* new_right) {
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison =
       comparison->CopyWithNewOperands(new_left, new_right);
   BranchInstr* new_branch =
       new (zone) BranchInstr(new_comparison, Thread::kNoDeoptId);
   return new_branch;
 }
 
-
 void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
   // Optimize some branches that test the value of a phi.  When it is safe
   // to do so, push the branch to each of the predecessor blocks.  This is
   // an optimization when (a) it can avoid materializing a boolean object at
   // the phi only to test its value, and (b) it can expose opportunities for
   // constant propagation and unreachable code elimination.  This
   // optimization is intended to run after inlining which creates
   // opportunities for optimization (a) and before constant folding which
   // can perform optimization (b).
 
@@ skipping 115 matching lines @@
   }
 
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
-
 static bool IsTrivialBlock(BlockEntryInstr* block, Definition* defn) {
   return (block->IsTargetEntry() && (block->PredecessorCount() == 1)) &&
          ((block->next() == block->last_instruction()) ||
           ((block->next() == defn) &&
            (defn->next() == block->last_instruction())));
 }
 
-
 static void EliminateTrivialBlock(BlockEntryInstr* block,
                                   Definition* instr,
                                   IfThenElseInstr* before) {
   block->UnuseAllInputs();
   block->last_instruction()->UnuseAllInputs();
 
   if ((block->next() == instr) &&
       (instr->next() == block->last_instruction())) {
     before->previous()->LinkTo(instr);
     instr->LinkTo(before);
   }
 }
 
-
 void IfConverter::Simplify(FlowGraph* flow_graph) {
   Zone* zone = flow_graph->zone();
   bool changed = false;
 
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph->postorder();
   for (BlockIterator it(postorder); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     JoinEntryInstr* join = block->AsJoinEntry();
 
     // Detect diamond control flow pattern which materializes a value depending
@@ skipping 80 matching lines @@
   }
 
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
-
 }  // namespace dart