clang-format runtime/vm

runtime/vm/flow_graph_builder.h

 // Copyright (c) 2012, 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_BUILDER_H_
 #define RUNTIME_VM_FLOW_GRAPH_BUILDER_H_
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 #include "vm/allocation.h"
@@ skipping 12 matching lines @@
 class LocalVariable;
 class ParsedFunction;
 class String;
 class TypeArguments;
 
 class NestedStatement;
 class TestGraphVisitor;
 
 // A class to collect the exits from an inlined function during graph
 // construction so they can be plugged into the caller's flow graph.
-class InlineExitCollector: public ZoneAllocated {
+class InlineExitCollector : public ZoneAllocated {
  public:
   InlineExitCollector(FlowGraph* caller_graph, Definition* call)
-      : caller_graph_(caller_graph), call_(call), exits_(4) { }
+      : caller_graph_(caller_graph), call_(call), exits_(4) {}
 
   void AddExit(ReturnInstr* exit);
 
   void Union(const InlineExitCollector* other);
 
   // Before replacing a call with a graph, the outer environment needs to be
   // attached to each instruction in the callee graph and the caller graph
   // needs to have its block and instruction ID state updated.
   // Additionally we need to remove all unreachable exits from the list of
   // collected exits.
@@ skipping 16 matching lines @@
 
   BlockEntryInstr* ExitBlockAt(intptr_t i) const {
     ASSERT(exits_[i].exit_block != NULL);
     return exits_[i].exit_block;
   }
 
   Instruction* LastInstructionAt(intptr_t i) const {
     return ReturnAt(i)->previous();
   }
 
-  Value* ValueAt(intptr_t i) const {
-    return ReturnAt(i)->value();
-  }
+  Value* ValueAt(intptr_t i) const { return ReturnAt(i)->value(); }
 
-  ReturnInstr* ReturnAt(intptr_t i) const {
-    return exits_[i].exit_return;
-  }
+  ReturnInstr* ReturnAt(intptr_t i) const { return exits_[i].exit_return; }
 
   static int LowestBlockIdFirst(const Data* a, const Data* b);
   void SortExits();
   void RemoveUnreachableExits(FlowGraph* callee_graph);
 
   Definition* JoinReturns(BlockEntryInstr** exit_block,
                           Instruction** last_instruction,
                           intptr_t try_index);
 
   Isolate* isolate() const { return caller_graph_->isolate(); }
@@ skipping 43 matching lines @@
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   intptr_t next_await_counter() { return jump_count_++; }
 
   ZoneGrowableArray<JoinEntryInstr*>* await_joins() const {
     return await_joins_;
   }
 
   void AddCatchEntry(CatchBlockEntryInstr* entry);
 
-  GraphEntryInstr* graph_entry() const {
-    return graph_entry_;
-  }
+  GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
-  intptr_t num_copied_params() const {
-    return num_copied_params_;
-  }
-  intptr_t num_non_copied_params() const {
-    return num_non_copied_params_;
-  }
-  intptr_t num_stack_locals() const {
-    return 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_; }
+  intptr_t num_stack_locals() const { return num_stack_locals_; }
 
   bool IsInlining() const { return (exit_collector_ != NULL); }
   InlineExitCollector* exit_collector() const { return exit_collector_; }
 
   ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes() const {
     return parsed_function_.deferred_prefixes();
   }
 
   intptr_t temp_count() const { return temp_count_; }
   intptr_t AllocateTemp() { return temp_count_++; }
@@ skipping 68 matching lines @@
 // function from an AstNode and next temporary index to a graph fragment
 // with a single entry and at most one exit.  The fragment is represented by
 // an (entry, exit) pair of Instruction pointers:
 //
 //   - (NULL, NULL): an empty and open graph fragment
 //   - (i0, NULL): a closed graph fragment which has only non-local exits
 //   - (i0, i1): an open graph fragment
 class EffectGraphVisitor : public AstNodeVisitor {
  public:
   explicit EffectGraphVisitor(FlowGraphBuilder* owner)
-      : owner_(owner),
-        entry_(NULL),
-        exit_(NULL) { }
+      : owner_(owner), entry_(NULL), exit_(NULL) {}
 
 #define DECLARE_VISIT(BaseName)                                                \
   virtual void Visit##BaseName##Node(BaseName##Node* node);
 
   FOR_EACH_NODE(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   FlowGraphBuilder* owner() const { return owner_; }
   Instruction* entry() const { return entry_; }
   Instruction* exit() const { return exit_; }
@@ skipping 45 matching lines @@
                              Value* value,
                              TokenPosition token_pos);
   Definition* BuildStoreExprTemp(Value* value, TokenPosition token_pos);
   Definition* BuildLoadExprTemp(TokenPosition token_pos);
 
   Definition* BuildStoreLocal(const LocalVariable& local,
                               Value* value,
                               TokenPosition token_pos);
   Definition* BuildLoadLocal(const LocalVariable& local,
                              TokenPosition token_pos);
-  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope,
-                                   TokenPosition token_pos);
-  LoadFieldInstr* BuildNativeGetter(
-      NativeBodyNode* node,
-      MethodRecognizer::Kind kind,
-      intptr_t offset,
-      const Type& type,
-      intptr_t class_id);
+  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope, TokenPosition token_pos);
+  LoadFieldInstr* BuildNativeGetter(NativeBodyNode* node,
+                                    MethodRecognizer::Kind kind,
+                                    intptr_t offset,
+                                    const Type& type,
+                                    intptr_t class_id);
   // Assumes setter parameter is named 'value'. Returns null constant.
-  ConstantInstr* DoNativeSetterStoreValue(
-      NativeBodyNode* node,
-      intptr_t offset,
-      StoreBarrierType emit_store_barrier);
+  ConstantInstr* DoNativeSetterStoreValue(NativeBodyNode* node,
+                                          intptr_t offset,
+                                          StoreBarrierType emit_store_barrier);
 
   // Helpers for translating parts of the AST.
   void BuildPushArguments(const ArgumentListNode& node,
                           ZoneGrowableArray<PushArgumentInstr*>* values);
 
   // Creates an instantiated type argument vector used in preparation of an
   // allocation call.
   // May be called only if allocating an object of a parameterized class.
-  Value* BuildInstantiatedTypeArguments(
-      TokenPosition token_pos,
-      const TypeArguments& type_arguments);
+  Value* BuildInstantiatedTypeArguments(TokenPosition token_pos,
+                                        const TypeArguments& type_arguments);
 
   void BuildTypecheckPushArguments(
       TokenPosition token_pos,
       PushArgumentInstr** push_instantiator_type_arguments);
   void BuildTypecheckArguments(TokenPosition token_pos,
                                Value** instantiator_type_arguments);
   Value* BuildInstantiator(TokenPosition token_pos);
   Value* BuildInstantiatorTypeArguments(TokenPosition token_pos,
                                         const Class& instantiator_class,
                                         Value* instantiator);
@@ skipping 41 matching lines @@
   void CloseFragment() { exit_ = NULL; }
 
   // Returns a local variable index for a temporary local that is
   // on top of the current expression stack.
   intptr_t GetCurrentTempLocalIndex() const;
 
   Value* BuildObjectAllocation(ConstructorCallNode* node);
   void BuildConstructorCall(ConstructorCallNode* node,
                             PushArgumentInstr* alloc_value);
 
-  void BuildSaveContext(const LocalVariable& variable,
-                        TokenPosition token_pos);
+  void BuildSaveContext(const LocalVariable& variable, TokenPosition token_pos);
   void BuildRestoreContext(const LocalVariable& variable,
                            TokenPosition token_pos);
 
   Definition* BuildStoreContext(Value* value, TokenPosition token_pos);
   Definition* BuildCurrentContext(TokenPosition token_pos);
 
   void BuildThrowNode(ThrowNode* node);
 
   StaticCallInstr* BuildStaticNoSuchMethodCall(
       const Class& target_class,
@@ skipping 36 matching lines @@
   void BuildInstanceCallConditional(InstanceCallNode* node);
 
   Thread* thread() const { return owner()->thread(); }
   Isolate* isolate() const { return owner()->isolate(); }
   Zone* zone() const { return owner()->zone(); }
 
  private:
   friend class TempLocalScope;  // For ReturnDefinition.
 
   // Helper to drop the result value.
-  virtual void ReturnValue(Value* value) {
-    Do(new DropTempsInstr(0, value));
-  }
+  virtual void ReturnValue(Value* value) { Do(new DropTempsInstr(0, value)); }
 
   // Specify a definition of the final result.  Adds the definition to
   // the graph, but normally overridden in subclasses.
   virtual void ReturnDefinition(Definition* definition) {
     // Constants have no effect, do not add them to graph otherwise SSA
     // builder will get confused.
     if (!definition->IsConstant()) {
       Do(definition);
     }
   }
 
   // Shared global state.
   FlowGraphBuilder* owner_;
 
   // Output parameters.
   Instruction* entry_;
   Instruction* exit_;
 };
 
 
 // Translate an AstNode to a control-flow graph fragment for both its effects
 // and value (e.g., for an expression in a value context).  Implements a
 // function from an AstNode and next temporary index to a graph fragment (as
 // in the EffectGraphVisitor), a next temporary index, and an intermediate
 // language Value.
 class ValueGraphVisitor : public EffectGraphVisitor {
  public:
   explicit ValueGraphVisitor(FlowGraphBuilder* owner)
-      : EffectGraphVisitor(owner), value_(NULL) { }
+      : EffectGraphVisitor(owner), value_(NULL) {}
 
   // Visit functions overridden by this class.
   virtual void VisitAssignableNode(AssignableNode* node);
   virtual void VisitConstructorCallNode(ConstructorCallNode* node);
   virtual void VisitBinaryOpNode(BinaryOpNode* node);
   virtual void VisitConditionalExprNode(ConditionalExprNode* node);
   virtual void VisitLoadLocalNode(LoadLocalNode* node);
   virtual void VisitStoreIndexedNode(StoreIndexedNode* node);
   virtual void VisitInstanceSetterNode(InstanceSetterNode* node);
   virtual void VisitInstanceGetterNode(InstanceGetterNode* node);
@@ skipping 36 matching lines @@
 //   - Both NULL: only non-local exits, truly closed
 //   - Neither NULL: true and false successors at the given addresses
 //
 // We expect that AstNode in test contexts either have only nonlocal exits
 // or else control flow has both true and false successors.
 //
 // The cis and token_pos are used in checked mode to verify that the
 // condition of the test is of type bool.
 class TestGraphVisitor : public ValueGraphVisitor {
  public:
-  TestGraphVisitor(FlowGraphBuilder* owner,
-                   TokenPosition condition_token_pos)
+  TestGraphVisitor(FlowGraphBuilder* owner, TokenPosition condition_token_pos)
       : ValueGraphVisitor(owner),
         true_successor_addresses_(1),
         false_successor_addresses_(1),
-        condition_token_pos_(condition_token_pos) { }
+        condition_token_pos_(condition_token_pos) {}
 
   void IfFalseGoto(JoinEntryInstr* join) const;
   void IfTrueGoto(JoinEntryInstr* join) const;
 
   BlockEntryInstr* CreateTrueSuccessor() const;
   BlockEntryInstr* CreateFalseSuccessor() const;
 
   virtual void VisitBinaryOpNode(BinaryOpNode* node);
 
   TokenPosition condition_token_pos() const { return condition_token_pos_; }
 
  private:
   // Construct and concatenate a Branch instruction to this graph fragment.
   // Closes the fragment and sets the output parameters.
   virtual void ReturnValue(Value* value);
 
   // Either merges the definition into a BranchInstr (Comparison, BooleanNegate)
   // or adds the definition to the graph and returns a use of its value.
   virtual void ReturnDefinition(Definition* definition);
 
   void MergeBranchWithComparison(ComparisonInstr* comp);
   void MergeBranchWithNegate(BooleanNegateInstr* comp);
 
   BlockEntryInstr* CreateSuccessorFor(
-    const GrowableArray<TargetEntryInstr**>& branches) const;
+      const GrowableArray<TargetEntryInstr**>& branches) const;
 
-  void ConnectBranchesTo(
-    const GrowableArray<TargetEntryInstr**>& branches,
-    JoinEntryInstr* join) const;
+  void ConnectBranchesTo(const GrowableArray<TargetEntryInstr**>& branches,
+                         JoinEntryInstr* join) const;
 
   // Output parameters.
   GrowableArray<TargetEntryInstr**> true_successor_addresses_;
   GrowableArray<TargetEntryInstr**> false_successor_addresses_;
 
   TokenPosition condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_BUILDER_H_