clang-format runtime/vm

runtime/vm/block_scheduler.cc

 // 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.
 
 #include "vm/block_scheduler.h"
 
 #include "vm/allocation.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/flow_graph.h"
@@ skipping 22 matching lines @@
     // block does not throw an exception.
     intptr_t count = GetEdgeCount(edge_counters, target->preorder_number());
     if ((count >= 0) && (entry_count != 0)) {
       double weight =
           static_cast<double>(count) / static_cast<double>(entry_count);
       target->set_edge_weight(weight);
     }
   } else {
     GotoInstr* jump = block->last_instruction()->AsGoto();
     if (jump != NULL) {
-      intptr_t count =
-          GetEdgeCount(edge_counters, block->preorder_number());
+      intptr_t count = GetEdgeCount(edge_counters, block->preorder_number());
       if ((count >= 0) && (entry_count != 0)) {
         double weight =
             static_cast<double>(count) / static_cast<double>(entry_count);
         jump->set_edge_weight(weight);
       }
     }
   }
 }
 
 
 void BlockScheduler::AssignEdgeWeights() const {
   if (!FLAG_reorder_basic_blocks) {
     return;
   }
 
-  const Array& ic_data_array = Array::Handle(flow_graph()->zone(),
-      flow_graph()->parsed_function().function().ic_data_array());
+  const Array& ic_data_array =
+      Array::Handle(flow_graph()->zone(),
+                    flow_graph()->parsed_function().function().ic_data_array());
   if (Compiler::IsBackgroundCompilation() && ic_data_array.IsNull()) {
     // Deferred loading cleared ic_data_array.
-    Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
-        "BlockScheduler: ICData array cleared");
+    Compiler::AbortBackgroundCompilation(
+        Thread::kNoDeoptId, "BlockScheduler: ICData array cleared");
   }
   if (ic_data_array.IsNull()) {
     ASSERT(Isolate::Current()->HasAttemptedReload());
     return;
   }
   Array& edge_counters = Array::Handle();
   edge_counters ^= ic_data_array.At(0);
 
   intptr_t entry_count = GetEdgeCount(
       edge_counters,
       flow_graph()->graph_entry()->normal_entry()->preorder_number());
   flow_graph()->graph_entry()->set_entry_count(entry_count);
 
   for (BlockIterator it = flow_graph()->reverse_postorder_iterator();
-       !it.Done();
-       it.Advance()) {
+       !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     Instruction* last = block->last_instruction();
     for (intptr_t i = 0; i < last->SuccessorCount(); ++i) {
       BlockEntryInstr* succ = last->SuccessorAt(i);
       SetEdgeWeight(block, succ, edge_counters, entry_count);
     }
   }
 }
 
 
 // A weighted control-flow graph edge.
 struct Edge {
   Edge(BlockEntryInstr* source, BlockEntryInstr* target, double weight)
-      : source(source), target(target), weight(weight) { }
+      : source(source), target(target), weight(weight) {}
 
   static int LowestWeightFirst(const Edge* a, const Edge* b);
 
   BlockEntryInstr* source;
   BlockEntryInstr* target;
   double weight;
 };
 
 
 // A linked list node in a chain of blocks.
 struct Link : public ZoneAllocated {
-  Link(BlockEntryInstr* block, Link* next) : block(block), next(next) { }
+  Link(BlockEntryInstr* block, Link* next) : block(block), next(next) {}
 
   BlockEntryInstr* block;
   Link* next;
 };
 
 
 // A chain of blocks with first and last pointers for fast concatenation and
 // a length to support adding a shorter chain's links to a longer chain.
 struct Chain : public ZoneAllocated {
   explicit Chain(BlockEntryInstr* block)
-      : first(new Link(block, NULL)), last(first), length(1) { }
+      : first(new Link(block, NULL)), last(first), length(1) {}
 
   Link* first;
   Link* last;
   intptr_t length;
 };
 
 
 int Edge::LowestWeightFirst(const Edge* a, const Edge* b) {
   if (a->weight < b->weight) {
     return -1;
@@ skipping 32 matching lines @@
   // sorted by weight.
   intptr_t block_count = flow_graph()->preorder().length();
   GrowableArray<Edge> edges(2 * block_count);
 
   // A map from a block's postorder number to the chain it is in.  Used to
   // implement a simple (ordered) union-find data structure.  Chains are
   // stored by pointer so that they are aliased (mutating one mutates all
   // shared ones).  Find(n) is simply chains[n].
   GrowableArray<Chain*> chains(block_count);
 
-  for (BlockIterator it = flow_graph()->postorder_iterator();
-       !it.Done();
+  for (BlockIterator it = flow_graph()->postorder_iterator(); !it.Done();
        it.Advance()) {
     BlockEntryInstr* block = it.Current();
     chains.Add(new Chain(block));
 
     Instruction* last = block->last_instruction();
     for (intptr_t i = 0; i < last->SuccessorCount(); ++i) {
       BlockEntryInstr* succ = last->SuccessorAt(i);
       double weight = 0.0;
       if (succ->IsTargetEntry()) {
         weight = succ->AsTargetEntry()->edge_weight();
@@ skipping 29 matching lines @@
   for (intptr_t i = block_count - 1; i >= 0; --i) {
     if (chains[i]->first->block == flow_graph()->postorder()[i]) {
       for (Link* link = chains[i]->first; link != NULL; link = link->next) {
         flow_graph()->CodegenBlockOrder(true)->Add(link->block);
       }
     }
   }
 }
 
 }  // namespace dart