clang-format runtime/vm

runtime/vm/flow_graph.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_FLOW_GRAPH_H_
 #define RUNTIME_VM_FLOW_GRAPH_H_
 
 #include "vm/bit_vector.h"
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/intermediate_language.h"
 #include "vm/parser.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 class BlockEffects;
 class FlowGraphBuilder;
 class ValueInliningContext;
 class VariableLivenessAnalysis;
 
 class BlockIterator : public ValueObject {
  public:
   explicit BlockIterator(const GrowableArray<BlockEntryInstr*>& block_order)
-      : block_order_(block_order), current_(0) { }
+      : block_order_(block_order), current_(0) {}
 
   BlockIterator(const BlockIterator& other)
       : ValueObject(),
         block_order_(other.block_order_),
-        current_(other.current_) { }
+        current_(other.current_) {}
 
   void Advance() {
     ASSERT(!Done());
     current_++;
   }
 
   bool Done() const { return current_ >= block_order_.length(); }
 
   BlockEntryInstr* Current() const { return block_order_[current_]; }
 
  private:
   const GrowableArray<BlockEntryInstr*>& block_order_;
   intptr_t current_;
 };
 
 
 struct ConstantPoolTrait {
   typedef ConstantInstr* Value;
   typedef const Object& Key;
   typedef ConstantInstr* Pair;
 
-  static Key KeyOf(Pair kv) {
-    return kv->value();
-  }
+  static Key KeyOf(Pair kv) { return kv->value(); }
 
-  static Value ValueOf(Pair kv) {
-    return kv;
-  }
+  static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) {
     if (key.IsSmi()) {
       return Smi::Cast(key).Value();
     }
     if (key.IsDouble()) {
-      return static_cast<intptr_t>(
-          bit_cast<int32_t, float>(
-              static_cast<float>(Double::Cast(key).value())));
+      return static_cast<intptr_t>(bit_cast<int32_t, float>(
+          static_cast<float>(Double::Cast(key).value())));
     }
     if (key.IsMint()) {
       return static_cast<intptr_t>(Mint::Cast(key).value());
     }
     if (key.IsString()) {
       return String::Cast(key).Hash();
     }
     return key.GetClassId();
   }
 
   static inline bool IsKeyEqual(Pair kv, Key key) {
     return kv->value().raw() == key.raw();
   }
 };
 
 
 // Class to encapsulate the construction and manipulation of the flow graph.
 class FlowGraph : public ZoneAllocated {
  public:
   FlowGraph(const ParsedFunction& parsed_function,
             GraphEntryInstr* graph_entry,
             intptr_t max_block_id);
 
   // Function properties.
-  const ParsedFunction& parsed_function() const {
-    return parsed_function_;
-  }
-  const Function& function() const {
-    return parsed_function_.function();
-  }
+  const ParsedFunction& parsed_function() const { return parsed_function_; }
+  const Function& function() const { return parsed_function_.function(); }
   intptr_t parameter_count() const {
     return num_copied_params_ + num_non_copied_params_;
   }
   intptr_t variable_count() const {
     return parameter_count() + parsed_function_.num_stack_locals();
   }
   intptr_t num_stack_locals() const {
     return parsed_function_.num_stack_locals();
   }
-  intptr_t num_copied_params() const {
-    return num_copied_params_;
-  }
-  intptr_t num_non_copied_params() const {
-    return num_non_copied_params_;
-  }
-  bool IsIrregexpFunction() const {
-    return function().IsIrregexpFunction();
-  }
+  intptr_t num_copied_params() const { return num_copied_params_; }
+  intptr_t num_non_copied_params() const { return num_non_copied_params_; }
+  bool IsIrregexpFunction() const { return function().IsIrregexpFunction(); }
 
   LocalVariable* CurrentContextVar() const {
     return parsed_function().current_context_var();
   }
 
   intptr_t CurrentContextEnvIndex() const {
     return parsed_function().current_context_var()->BitIndexIn(
         num_non_copied_params_);
   }
 
   // Flow graph orders.
-  const GrowableArray<BlockEntryInstr*>& preorder() const {
-    return preorder_;
-  }
+  const GrowableArray<BlockEntryInstr*>& preorder() const { return preorder_; }
   const GrowableArray<BlockEntryInstr*>& postorder() const {
     return postorder_;
   }
   const GrowableArray<BlockEntryInstr*>& reverse_postorder() const {
     return reverse_postorder_;
   }
   static bool ShouldReorderBlocks(const Function& function, bool is_optimized);
   GrowableArray<BlockEntryInstr*>* CodegenBlockOrder(bool is_optimized);
 
   // Iterators.
@@ skipping 23 matching lines @@
                                    RawFunction::Kind kind) const;
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread()->zone(); }
   Isolate* isolate() const { return thread()->isolate(); }
 
   intptr_t max_block_id() const { return max_block_id_; }
   void set_max_block_id(intptr_t id) { max_block_id_ = id; }
   intptr_t allocate_block_id() { return ++max_block_id_; }
 
-  GraphEntryInstr* graph_entry() const {
-    return graph_entry_;
-  }
+  GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
-  ConstantInstr* constant_null() const {
-    return constant_null_;
-  }
+  ConstantInstr* constant_null() const { return constant_null_; }
 
-  ConstantInstr* constant_dead() const {
-    return constant_dead_;
-  }
+  ConstantInstr* constant_dead() const { return constant_dead_; }
 
   ConstantInstr* constant_empty_context() const {
     return constant_empty_context_;
   }
 
   intptr_t alloc_ssa_temp_index() { return current_ssa_temp_index_++; }
 
   void AllocateSSAIndexes(Definition* def) {
     ASSERT(def);
     def->set_ssa_temp_index(alloc_ssa_temp_index());
@@ skipping 85 matching lines @@
   }
 
   bool IsCompiledForOsr() const { return graph_entry()->IsCompiledForOsr(); }
 
   void AddToDeferredPrefixes(ZoneGrowableArray<const LibraryPrefix*>* from);
 
   ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes() const {
     return deferred_prefixes_;
   }
 
-  BitVector* captured_parameters() const {
-    return captured_parameters_;
-  }
+  BitVector* captured_parameters() const { return captured_parameters_; }
 
   intptr_t inlining_id() const { return inlining_id_; }
   void set_inlining_id(intptr_t value) { inlining_id_ = value; }
 
   // Returns true if any instructions were canonicalized away.
   bool Canonicalize();
 
   void SelectRepresentations();
 
   void WidenSmiToInt32();
@@ skipping 10 matching lines @@
 
  private:
   friend class IfConverter;
   friend class BranchSimplifier;
   friend class ConstantPropagator;
   friend class DeadCodeElimination;
 
   // SSA transformation methods and fields.
   void ComputeDominators(GrowableArray<BitVector*>* dominance_frontier);
 
-  void CompressPath(
-      intptr_t start_index,
-      intptr_t current_index,
-      GrowableArray<intptr_t>* parent,
-      GrowableArray<intptr_t>* label);
+  void CompressPath(intptr_t start_index,
+                    intptr_t current_index,
+                    GrowableArray<intptr_t>* parent,
+                    GrowableArray<intptr_t>* label);
 
   void Rename(GrowableArray<PhiInstr*>* live_phis,
               VariableLivenessAnalysis* variable_liveness,
               ZoneGrowableArray<Definition*>* inlining_parameters);
-  void RenameRecursive(
-      BlockEntryInstr* block_entry,
-      GrowableArray<Definition*>* env,
-      GrowableArray<PhiInstr*>* live_phis,
-      VariableLivenessAnalysis* variable_liveness);
+  void RenameRecursive(BlockEntryInstr* block_entry,
+                       GrowableArray<Definition*>* env,
+                       GrowableArray<PhiInstr*>* live_phis,
+                       VariableLivenessAnalysis* variable_liveness);
 
   void AttachEnvironment(Instruction* instr, GrowableArray<Definition*>* env);
 
-  void InsertPhis(
-      const GrowableArray<BlockEntryInstr*>& preorder,
-      const GrowableArray<BitVector*>& assigned_vars,
-      const GrowableArray<BitVector*>& dom_frontier,
-      GrowableArray<PhiInstr*>* live_phis);
+  void InsertPhis(const GrowableArray<BlockEntryInstr*>& preorder,
+                  const GrowableArray<BitVector*>& assigned_vars,
+                  const GrowableArray<BitVector*>& dom_frontier,
+                  GrowableArray<PhiInstr*>* live_phis);
 
   void RemoveDeadPhis(GrowableArray<PhiInstr*>* live_phis);
 
   void ReplacePredecessor(BlockEntryInstr* old_block,
                           BlockEntryInstr* new_block);
 
   // Find the natural loop for the back edge m->n and attach loop
   // information to block n (loop header). The algorithm is described in
   // "Advanced Compiler Design & Implementation" (Muchnick) p192.
   // Returns a BitVector indexed by block pre-order number where each bit
@@ skipping 15 matching lines @@
   void OptimizeLeftShiftBitAndSmiOp(
       ForwardInstructionIterator* current_iterator,
       Definition* bit_and_instr,
       Definition* left_instr,
       Definition* right_instr);
 
   void TryMergeTruncDivMod(GrowableArray<BinarySmiOpInstr*>* merge_candidates);
   void TryMergeMathUnary(
       GrowableArray<InvokeMathCFunctionInstr*>* merge_candidates);
 
-  void AppendExtractNthOutputForMerged(Definition* instr, intptr_t ix,
-                                       Representation rep, intptr_t cid);
+  void AppendExtractNthOutputForMerged(Definition* instr,
+                                       intptr_t ix,
+                                       Representation rep,
+                                       intptr_t cid);
 
   Thread* thread_;
 
   // DiscoverBlocks computes parent_ and assigned_vars_ which are then used
   // if/when computing SSA.
   GrowableArray<intptr_t> parent_;
   GrowableArray<BitVector*> assigned_vars_;
 
   intptr_t current_ssa_temp_index_;
   intptr_t max_block_id_;
@@ skipping 24 matching lines @@
 };
 
 
 class LivenessAnalysis : public ValueObject {
  public:
   LivenessAnalysis(intptr_t variable_count,
                    const GrowableArray<BlockEntryInstr*>& postorder);
 
   void Analyze();
 
-  virtual ~LivenessAnalysis() { }
+  virtual ~LivenessAnalysis() {}
 
   BitVector* GetLiveInSetAt(intptr_t postorder_number) const {
     return live_in_[postorder_number];
   }
 
   BitVector* GetLiveOutSetAt(intptr_t postorder_number) const {
     return live_out_[postorder_number];
   }
 
   BitVector* GetLiveInSet(BlockEntryInstr* block) const {
@@ skipping 77 matching lines @@
 
   // Per block sets of available blocks. Block A is available at the block B if
   // and only if A dominates B and all paths from A to B are free of side
   // effects.
   GrowableArray<BitVector*> available_at_;
 };
 
 
 class DefinitionWorklist : public ValueObject {
  public:
-  DefinitionWorklist(FlowGraph* flow_graph,
-                     intptr_t initial_capacity)
+  DefinitionWorklist(FlowGraph* flow_graph, intptr_t initial_capacity)
       : defs_(initial_capacity),
-        contains_vector_(
-            new BitVector(flow_graph->zone(),
-                          flow_graph->current_ssa_temp_index())) {
-  }
+        contains_vector_(new BitVector(flow_graph->zone(),
+                                       flow_graph->current_ssa_temp_index())) {}
 
   void Add(Definition* defn) {
     if (!Contains(defn)) {
       defs_.Add(defn);
       contains_vector_->Add(defn->ssa_temp_index());
     }
   }
 
   bool Contains(Definition* defn) const {
     return (defn->ssa_temp_index() >= 0) &&
-        contains_vector_->Contains(defn->ssa_temp_index());
+           contains_vector_->Contains(defn->ssa_temp_index());
   }
 
-  bool IsEmpty() const {
-    return defs_.is_empty();
-  }
+  bool IsEmpty() const { return defs_.is_empty(); }
 
   Definition* RemoveLast() {
     Definition* defn = defs_.RemoveLast();
     contains_vector_->Remove(defn->ssa_temp_index());
     return defn;
   }
 
   const GrowableArray<Definition*>& definitions() const { return defs_; }
   BitVector* contains_vector() const { return contains_vector_; }
 
   void Clear() {
     defs_.TruncateTo(0);
     contains_vector_->Clear();
   }
 
  private:
   GrowableArray<Definition*> defs_;
   BitVector* contains_vector_;
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_H_