clang-format runtime/vm

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 {
 
 // Returns true if the given phi has a single input use and
 // is used in the environments either at the corresponding block entry or
 // at the same instruction where input use is.
 static bool PhiHasSingleUse(PhiInstr* phi, Value* use) {
   if ((use->next_use() != NULL) || (phi->input_use_list() != use)) {
     return false;
   }
 
   BlockEntryInstr* block = phi->block();
-  for (Value* env_use = phi->env_use_list();
-       env_use != NULL;
+  for (Value* env_use = phi->env_use_list(); env_use != NULL;
        env_use = env_use->next_use()) {
     if ((env_use->instruction() != block) &&
         (env_use->instruction() != use->instruction())) {
       return false;
     }
   }
 
   return true;
 }
 
@@ skipping 15 matching lines @@
     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);
+  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());
+      new (zone) JoinEntryInstr(target->block_id(), target->try_index());
   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);
+  BranchInstr* new_branch = new (zone) BranchInstr(new_comparison);
   new_branch->set_is_checked(branch->is_checked());
   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
@@ skipping 27 matching lines @@
       // The branch will be copied and pushed to all the join's
       // predecessors.  Convert the true and false target blocks into join
       // blocks to join the control flows from all of the true
       // (respectively, false) targets of the copied branches.
       //
       // The converted join block will have no phis, so it cannot be another
       // instance of the pattern.  There is thus no need to add it to the
       // worklist.
       BranchInstr* branch = block->last_instruction()->AsBranch();
       ASSERT(branch != NULL);
-      JoinEntryInstr* join_true =
-          ToJoinEntry(zone, branch->true_successor());
-      JoinEntryInstr* join_false =
-          ToJoinEntry(zone, branch->false_successor());
+      JoinEntryInstr* join_true = ToJoinEntry(zone, branch->true_successor());
+      JoinEntryInstr* join_false = ToJoinEntry(zone, branch->false_successor());
 
       ComparisonInstr* comparison = branch->comparison();
       PhiInstr* phi = comparison->left()->definition()->AsPhi();
       ConstantInstr* constant = comparison->right()->definition()->AsConstant();
       ASSERT(constant != NULL);
       // Copy the constant and branch and push it to all the predecessors.
       for (intptr_t i = 0, count = block->PredecessorCount(); i < count; ++i) {
         GotoInstr* old_goto =
             block->PredecessorAt(i)->last_instruction()->AsGoto();
         ASSERT(old_goto != NULL);
 
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
         Value* new_left = phi->InputAt(i)->Copy(zone);
-        Value* new_right = new(zone) Value(constant);
+        Value* new_right = new (zone) Value(constant);
         BranchInstr* new_branch =
             CloneBranch(zone, branch, new_left, new_right);
         if (branch->env() == NULL) {
           new_branch->InheritDeoptTarget(zone, old_goto);
         } else {
           // Take the environment from the branch if it has one.
           new_branch->InheritDeoptTarget(zone, branch);
           // InheritDeoptTarget gave the new branch's comparison the same
           // deopt id that it gave the new branch.  The id should be the
           // deopt id of the original comparison.
           new_branch->comparison()->SetDeoptId(*comparison);
           // The phi can be used in the branch's environment.  Rename such
           // uses.
-          for (Environment::DeepIterator it(new_branch->env());
-               !it.Done();
+          for (Environment::DeepIterator it(new_branch->env()); !it.Done();
                it.Advance()) {
             Value* use = it.CurrentValue();
             if (use->definition() == phi) {
               Definition* replacement = phi->InputAt(i)->definition();
               use->RemoveFromUseList();
               use->set_definition(replacement);
               replacement->AddEnvUse(use);
             }
           }
         }
 
         new_branch->InsertBefore(old_goto);
         new_branch->set_next(NULL);  // Detaching the goto from the graph.
         old_goto->UnuseAllInputs();
 
         // Update the predecessor block.  We may have created another
         // instance of the pattern so add it to the worklist if necessary.
         BlockEntryInstr* branch_block = new_branch->GetBlock();
         branch_block->set_last_instruction(new_branch);
         if (branch_block->IsJoinEntry()) worklist.Add(branch_block);
 
         // Connect the branch to the true and false joins, via empty target
         // blocks.
-        TargetEntryInstr* true_target =
-            new(zone) TargetEntryInstr(flow_graph->max_block_id() + 1,
-                                          block->try_index());
+        TargetEntryInstr* true_target = new (zone) TargetEntryInstr(
+            flow_graph->max_block_id() + 1, block->try_index());
         true_target->InheritDeoptTarget(zone, join_true);
-        TargetEntryInstr* false_target =
-            new(zone) TargetEntryInstr(flow_graph->max_block_id() + 2,
-                                          block->try_index());
+        TargetEntryInstr* false_target = new (zone) TargetEntryInstr(
+            flow_graph->max_block_id() + 2, block->try_index());
         false_target->InheritDeoptTarget(zone, join_false);
         flow_graph->set_max_block_id(flow_graph->max_block_id() + 2);
         *new_branch->true_successor_address() = true_target;
         *new_branch->false_successor_address() = false_target;
-        GotoInstr* goto_true = new(zone) GotoInstr(join_true);
+        GotoInstr* goto_true = new (zone) GotoInstr(join_true);
         goto_true->InheritDeoptTarget(zone, join_true);
         true_target->LinkTo(goto_true);
         true_target->set_last_instruction(goto_true);
-        GotoInstr* goto_false = new(zone) GotoInstr(join_false);
+        GotoInstr* goto_false = new (zone) GotoInstr(join_false);
         goto_false->InheritDeoptTarget(zone, join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
       block->UnuseAllInputs();
       ASSERT(!phi->HasUses());
     }
   }
 
   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())));
+         ((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) &&
@@ skipping 26 matching lines @@
     //   v2 = Constant(...)
     //   goto B_block
     // B_block:
     //   v3 = phi(v1, v2) -- single phi
     //
     // and replace it with
     //
     // Ba:
     //   v3 = IfThenElse(COMP ? v1 : v2)
     //
-    if ((join != NULL) &&
-        (join->phis() != NULL) &&
-        (join->phis()->length() == 1) &&
-        (block->PredecessorCount() == 2)) {
+    if ((join != NULL) && (join->phis() != NULL) &&
+        (join->phis()->length() == 1) && (block->PredecessorCount() == 2)) {
       BlockEntryInstr* pred1 = block->PredecessorAt(0);
       BlockEntryInstr* pred2 = block->PredecessorAt(1);
 
       PhiInstr* phi = (*join->phis())[0];
       Value* v1 = phi->InputAt(0);
       Value* v2 = phi->InputAt(1);
 
       if (IsTrivialBlock(pred1, v1->definition()) &&
           IsTrivialBlock(pred2, v2->definition()) &&
           (pred1->PredecessorAt(0) == pred2->PredecessorAt(0))) {
         BlockEntryInstr* pred = pred1->PredecessorAt(0);
         BranchInstr* branch = pred->last_instruction()->AsBranch();
         ComparisonInstr* comparison = branch->comparison();
 
         // Check if the platform supports efficient branchless IfThenElseInstr
         // for the given combination of comparison and values flowing from
         // false and true paths.
         if (IfThenElseInstr::Supports(comparison, v1, v2)) {
           Value* if_true = (pred1 == branch->true_successor()) ? v1 : v2;
           Value* if_false = (pred2 == branch->true_successor()) ? v1 : v2;
 
-          ComparisonInstr* new_comparison =
-              comparison->CopyWithNewOperands(
-                  comparison->left()->Copy(zone),
-                  comparison->right()->Copy(zone));
-          IfThenElseInstr* if_then_else = new(zone) IfThenElseInstr(
-              new_comparison,
-              if_true->Copy(zone),
-              if_false->Copy(zone));
-          flow_graph->InsertBefore(branch,
-                                   if_then_else,
-                                   NULL,
+          ComparisonInstr* new_comparison = comparison->CopyWithNewOperands(
+              comparison->left()->Copy(zone), comparison->right()->Copy(zone));
+          IfThenElseInstr* if_then_else = new (zone) IfThenElseInstr(
+              new_comparison, if_true->Copy(zone), if_false->Copy(zone));
+          flow_graph->InsertBefore(branch, if_then_else, NULL,
                                    FlowGraph::kValue);
 
           phi->ReplaceUsesWith(if_then_else);
 
           // Connect IfThenElseInstr to the first instruction in the merge block
           // effectively eliminating diamond control flow.
           // Current block as well as pred1 and pred2 blocks are no longer in
           // the graph at this point.
           if_then_else->LinkTo(join->next());
           pred->set_last_instruction(join->last_instruction());
@@ skipping 24 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